How to use

AbstractEditor

in

ch.cyberduck.core.editor

@Override
protected void finalize() throws Throwable {
  try {
    this.delete();
  }
  finally {
    super.finalize();
  }
}

  @Override
  public int hashCode() {
    return editor != null ? editor.hashCode() : 0;
  }
}

@Override
public void cleanup(final Transfer upload) {
  editor.setModified(false);
}

public EditOpenWorker(final Host bookmark, final AbstractEditor editor,
           final TransferErrorCallback callback,
           final ApplicationQuitCallback quit,
           final ProgressListener listener,
           final FileWatcherListener watcher, final NotificationService notification) {
  this.editor = editor;
  this.callback = callback;
  this.quit = quit;
  this.notification = notification;
  this.download = new DownloadTransfer(bookmark, editor.getRemote(), editor.getLocal(),
      new DownloadDuplicateFilter()) {
    @Override
    public TransferAction action(final Session<?> source, final Session<?> destination, final boolean resumeRequested, final boolean reloadRequested,
                   final TransferPrompt prompt, final ListProgressListener listener) {
      return TransferAction.trash;
    }
  };
  this.listener = listener;
  this.watcher = watcher;
}

@Override
public Transfer run(final Session<?> session) throws BackgroundException {
  final Path file = editor.getRemote();
  if(log.isDebugEnabled()) {
    log.debug(String.format("Run edit action for editor %s", file));
  }
  // Delete any existing file which might be used by a watch editor already
  final TransferOptions options = new TransferOptions();
  options.quarantine = false;
  options.open = false;
  final SingleTransferWorker worker
    = new SingleTransferWorker(session, session, download, options, new TransferSpeedometer(download),
      new DisabledTransferPrompt(), callback,
    listener, new DisabledStreamListener(), new DisabledLoginCallback(), new DisabledPasswordCallback(), notification);
  worker.run();
  if(!download.isComplete()) {
    log.warn(String.format("File size changed for %s", file));
  }
  try {
    editor.edit(quit, watcher);
  }
  catch(IOException e) {
    throw new DefaultIOExceptionMappingService().map(e);
  }
  return download;
}

@Override
public String getActivity() {
  return MessageFormat.format(LocaleFactory.localizedString("Downloading {0}", "Status"),
      editor.getRemote().getName());
}

/**
 * Watch for changes in external editor
 *
 * @param quit Callback
 */
protected void edit(final ApplicationQuitCallback quit, final FileWatcherListener listener) throws IOException {
  if(!applicationFinder.isInstalled(application)) {
    log.warn(String.format("No editor application configured for %s", local));
    if(applicationLauncher.open(local)) {
      this.watch(local, listener);
    }
    else {
      throw new IOException(String.format("Failed to open default application for %s",
        local.getName()));
    }
  }
  else if(applicationLauncher.open(local, application, quit)) {
    this.watch(local, listener);
  }
  else {
    throw new IOException(String.format("Failed to open application %s for %s",
      application.getName(), local.getName()));
  }
}

public EditSaveWorker(final Host bookmark, final AbstractEditor editor,
           final TransferErrorCallback callback, final ProgressListener listener, final NotificationService notification) {
  this.editor = editor;
  this.callback = callback;
  this.notification = notification;
  this.upload = new UploadTransfer(bookmark, editor.getRemote(), editor.getLocal(), new NullFilter<Local>()) {
    @Override
    public TransferAction action(final Session<?> source,
                   final Session<?> destination, final boolean resumeRequested, final boolean reloadRequested,
                   final TransferPrompt prompt, final ListProgressListener listener) {
      return TransferAction.overwrite;
    }
    @Override
    public AbstractUploadFilter filter(final Session<?> session, final Session<?> destination, final TransferAction action, final ProgressListener listener) {
      return super.filter(session, destination, action, listener).withOptions(new UploadFilterOptions()
          .withTemporary(PreferencesFactory.get().getBoolean("queue.upload.file.temporary"))
          .withPermission(PreferencesFactory.get().getBoolean("editor.upload.permissions.change")));
    }
  };
  this.listener = listener;
}

@Override
public String getActivity() {
  return MessageFormat.format(LocaleFactory.localizedString("Uploading {0}", "Status"),
      editor.getRemote().getName());
}

  @Override
  public void callback() {
    quit.callback();
    delete();
  }
}, this.listener, listener, notification) {

@Override
public Transfer run(final Session<?> session) throws BackgroundException {
  if(log.isDebugEnabled()) {
    log.debug(String.format("Run upload action for editor %s", editor));
  }
  final SingleTransferWorker worker
    = new SingleTransferWorker(session, session, upload, new TransferOptions(),
      new TransferSpeedometer(upload), new DisabledTransferPrompt(), callback,
    listener, new DisabledStreamListener(), new DisabledLoginCallback(), new DisabledPasswordCallback(), notification);
  worker.run();
  if(!upload.isComplete()) {
    log.warn(String.format("File size changed for %s", editor.getRemote()));
  }
  else {
    // Update known remote file size
    editor.getRemote().attributes().setSize(upload.getTransferred());
  }
  return upload;
}

  @Override
  public int hashCode() {
    return editor != null ? editor.hashCode() : 0;
  }
}

  @Override
  public void delete() {
    if(log.isDebugEnabled()) {
      log.debug(String.format("Close monitor %s", monitor));
    }
    monitor.close();
    super.delete();
  }
}

  @Override
  public void delete() {
    if(log.isDebugEnabled()) {
      log.debug(String.format("Close monitor %s", monitor));
    }
    monitor.close();
    super.delete();
  }
}