MsSpectrumPlotWindowController.java

/*
 * Copyright 2006-2015 The MZmine 3 Development Team
 * 
 * This file is part of MZmine 3.
 * 
 * MZmine 3 is free software; you can redistribute it and/or modify it under the terms of the GNU
 * General Public License as published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 * 
 * MZmine 3 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
 * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License along with MZmine 3; if not,
 * write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
 * USA
 */

package io.github.mzmine.modules.plots.msspectrum;

import java.awt.BasicStroke;
import java.awt.Font;
import java.awt.Stroke;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Rectangle2D;
import java.io.File;
import java.net.URL;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

import javax.annotation.Nonnull;

import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.axis.ValueAxis;
import org.jfree.chart.block.BlockBorder;
import org.jfree.chart.labels.XYItemLabelGenerator;
import org.jfree.chart.plot.DatasetRenderingOrder;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.xy.AbstractXYItemRenderer;
import org.jfree.chart.renderer.xy.StandardXYBarPainter;
import org.jfree.chart.renderer.xy.XYBarRenderer;
import org.jfree.chart.renderer.xy.XYItemRenderer;
import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
import org.jfree.chart.title.LegendTitle;
import org.jfree.chart.title.TextTitle;
import org.jfree.data.RangeType;
import org.jfree.ui.RectangleEdge;
import org.jfree.ui.RectangleInsets;

import com.google.common.base.Preconditions;
import com.google.common.collect.Range;

import io.github.msdk.datamodel.datastore.DataPointStore;
import io.github.msdk.datamodel.datastore.DataPointStoreFactory;
import io.github.msdk.datamodel.files.FileType;
import io.github.msdk.datamodel.impl.MSDKObjectBuilder;
import io.github.msdk.datamodel.msspectra.MsSpectrum;
import io.github.msdk.datamodel.msspectra.MsSpectrumType;
import io.github.msdk.datamodel.rawdata.IsolationInfo;
import io.github.msdk.datamodel.rawdata.MsFunction;
import io.github.msdk.datamodel.rawdata.MsScan;
import io.github.msdk.datamodel.rawdata.RawDataFile;
import io.github.msdk.io.mgf.MgfFileExportMethod;
import io.github.msdk.io.msp.MspExportAlgorithm;
import io.github.msdk.io.mzml.MzMLFileExportMethod;
import io.github.msdk.io.txt.TxtExportAlgorithm;
import io.github.msdk.io.txt.TxtImportAlgorithm;
import io.github.msdk.spectra.isotopepattern.IsotopePatternGeneratorAlgorithm;
import io.github.msdk.spectra.splash.SplashCalculationAlgorithm;
import io.github.msdk.util.MsScanUtil;
import io.github.mzmine.gui.MZmineGUI;
import io.github.mzmine.main.MZmineCore;
import io.github.mzmine.modules.plots.chromatogram.ChromatogramPlotModule;
import io.github.mzmine.modules.plots.chromatogram.ChromatogramPlotParameters;
import io.github.mzmine.modules.plots.isotopepattern.IsotopePatternPlotModule;
import io.github.mzmine.modules.plots.isotopepattern.IsotopePatternPlotParameters;
import io.github.mzmine.modules.plots.msspectrum.datasets.MsSpectrumDataSet;
import io.github.mzmine.modules.plots.spectrumparser.SpectrumParserPlotModule;
import io.github.mzmine.modules.plots.spectrumparser.SpectrumParserPlotParameters;
import io.github.mzmine.parameters.ParameterSet;
import io.github.mzmine.parameters.parametertypes.selectors.RawDataFilesSelection;
import io.github.mzmine.parameters.parametertypes.selectors.ScanSelection;
import io.github.mzmine.project.MZmineProject;
import io.github.mzmine.util.JavaFXUtil;
import io.github.mzmine.util.MsScanUtils;
import io.github.mzmine.util.jfreechart.ChartNodeJFreeChart;
import io.github.mzmine.util.jfreechart.IntelligentItemLabelGenerator;
import io.github.mzmine.util.jfreechart.JFreeChartUtils;
import io.github.mzmine.util.jfreechart.JFreeChartUtils.ImgFileType;
import io.github.mzmine.util.jfreechart.ManualZoomDialog;
import javafx.application.Platform;
import javafx.beans.property.BooleanProperty;
import javafx.beans.property.DoubleProperty;
import javafx.beans.property.SimpleBooleanProperty;
import javafx.beans.property.SimpleDoubleProperty;
import javafx.collections.FXCollections;
import javafx.collections.ListChangeListener.Change;
import javafx.collections.ObservableList;
import javafx.event.Event;
import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.scene.Cursor;
import javafx.scene.control.ButtonType;
import javafx.scene.control.Menu;
import javafx.scene.control.MenuItem;
import javafx.scene.control.TextInputDialog;
import javafx.scene.input.Clipboard;
import javafx.scene.input.ClipboardContent;
import javafx.scene.input.ContextMenuEvent;
import javafx.scene.input.KeyCode;
import javafx.scene.input.KeyEvent;
import javafx.scene.layout.BorderPane;
import javafx.scene.paint.Color;
import javafx.stage.FileChooser;
import javafx.stage.FileChooser.ExtensionFilter;
import javafx.stage.Modality;
import javafx.stage.Stage;
import javafx.stage.Window;

/**
 * MS spectrum plot window
 */
public class MsSpectrumPlotWindowController {

  // Colors
  private static final Color gridColor = Color.rgb(220, 220, 220, 0.5);
  private static final Color labelsColor = Color.BLACK;
  private static final Color backgroundColor = Color.WHITE;
  private static final Color[] plotColors = {Color.rgb(0, 0, 192), // blue
      Color.rgb(192, 0, 0), // red
      Color.rgb(0, 192, 0), // green
      Color.MAGENTA, Color.CYAN, Color.ORANGE};

  private static final Font titleFont = new Font("SansSerif", Font.BOLD, 12);

  private static final String LAYERS_DIALOG_FXML = "MsSpectrumLayersDialog.fxml";

  private final ObservableList<MsSpectrumDataSet> datasets = FXCollections.observableArrayList();
  private int numberOfDataSets = 0;

  private final DoubleProperty mzShift = new SimpleDoubleProperty(this, "mzShift", 0.0);
  private final BooleanProperty itemLabelsVisible =
      new SimpleBooleanProperty(this, "itemLabelsVisible", true);
  private final BooleanProperty legendVisible =
      new SimpleBooleanProperty(this, "legendVisible", true);

  private File lastSaveDirectory;

  private TextTitle chartTitle, chartSubTitle;

  @FXML
  private BorderPane chartPane;

  @FXML
  private ChartNodeJFreeChart chartNode;

  @FXML
  private MenuItem setToMenuItem, showXICMenuItem;

  @FXML
  private Menu findMSMSMenu, removeDatasetMenu;

  public void initialize() {

    final JFreeChart chart = chartNode.getChart();
    final XYPlot plot = chart.getXYPlot();

    // Do not set colors and strokes dynamically. They are instead provided
    // by the dataset and configured in configureRenderer()
    plot.setDrawingSupplier(null);
    plot.setDomainGridlinePaint(JavaFXUtil.convertColorToAWT(gridColor));
    plot.setRangeGridlinePaint(JavaFXUtil.convertColorToAWT(gridColor));
    plot.setBackgroundPaint(JavaFXUtil.convertColorToAWT(backgroundColor));
    plot.setAxisOffset(new RectangleInsets(5.0, 5.0, 5.0, 5.0));
    plot.setDatasetRenderingOrder(DatasetRenderingOrder.FORWARD);
    plot.setDomainCrosshairVisible(false);
    plot.setRangeCrosshairVisible(false);

    // chart properties
    chart.setBackgroundPaint(JavaFXUtil.convertColorToAWT(backgroundColor));

    // legend properties
    LegendTitle legend = chart.getLegend();
    // legend.setItemFont(legendFont);
    legend.setFrame(BlockBorder.NONE);

    // set the X axis (m/z) properties
    NumberAxis xAxis = (NumberAxis) plot.getDomainAxis();
    xAxis.setLabel("m/z");
    xAxis.setUpperMargin(0.03);
    xAxis.setLowerMargin(0.03);
    xAxis.setRangeType(RangeType.POSITIVE);
    xAxis.setTickLabelInsets(new RectangleInsets(0, 0, 20, 20));

    // set the Y axis (intensity) properties
    NumberAxis yAxis = (NumberAxis) plot.getRangeAxis();
    yAxis.setLabel("Intensity");
    yAxis.setRangeType(RangeType.POSITIVE);
    yAxis.setAutoRangeIncludesZero(true);

    // set the fixed number formats, because otherwise JFreeChart sometimes
    // shows exponent, sometimes it doesn't
    DecimalFormat mzFormat = MZmineCore.getConfiguration().getMZFormat();
    xAxis.setNumberFormatOverride(mzFormat);
    DecimalFormat intensityFormat = MZmineCore.getConfiguration().getIntensityFormat();
    yAxis.setNumberFormatOverride(intensityFormat);

    chartTitle = chartNode.getChart().getTitle();
    chartTitle.setMargin(5, 0, 0, 0);
    chartTitle.setFont(titleFont);

    chartNode.setCursor(Cursor.CROSSHAIR);

    // Remove the dataset if it is removed from the list
    datasets.addListener((Change<? extends MsSpectrumDataSet> c) -> {
      while (c.next()) {
        if (c.wasRemoved()) {
          for (MsSpectrumDataSet ds : c.getRemoved()) {
            int index = plot.indexOf(ds);
            plot.setDataset(index, null);
          }
        }
      }
    });

    itemLabelsVisible.addListener((prop, oldVal, newVal) -> {
      for (MsSpectrumDataSet dataset : datasets) {
        int datasetIndex = plot.indexOf(dataset);
        XYItemRenderer renderer = plot.getRenderer(datasetIndex);
        renderer.setBaseItemLabelsVisible(newVal);
      }
    });

    legendVisible.addListener((prop, oldVal, newVal) -> {
      legend.setVisible(newVal);
    });

  }

  /**
   * Add a new spectrum to the plot.
   * 
   * @param spectrum
   */
  public void addSpectrum(@Nonnull MsSpectrum spectrum, @Nonnull String name) {

    Preconditions.checkNotNull(spectrum);

    if (!Platform.isFxApplicationThread()) {
      throw new IllegalStateException(
          "Not on FX application thread; currentThread = " + Thread.currentThread().getName());
    }

    MsSpectrumDataSet newDataSet = new MsSpectrumDataSet(spectrum, name);
    newDataSet.mzShiftProperty().bind(mzShift);
    datasets.add(newDataSet);

    final int datasetIndex = numberOfDataSets;
    numberOfDataSets++;

    final XYPlot plot = chartNode.getChart().getXYPlot();

    final Color newColor = plotColors[datasetIndex % plotColors.length];
    newDataSet.setColor(newColor);

    configureRenderer(newDataSet, datasetIndex);

    newDataSet.renderingTypeProperty().addListener(e -> {
      Platform.runLater(() -> configureRenderer(newDataSet, datasetIndex));
    });
    newDataSet.colorProperty().addListener(e -> {
      Platform.runLater(() -> configureRenderer(newDataSet, datasetIndex));
    });
    newDataSet.lineThicknessProperty().addListener(e -> {
      Platform.runLater(() -> configureRenderer(newDataSet, datasetIndex));
    });
    newDataSet.showDataPointsProperty().addListener(e -> {
      Platform.runLater(() -> configureRenderer(newDataSet, datasetIndex));
    });

    // Once everything is configured, add the dataset to the plot
    plot.setDataset(datasetIndex, newDataSet);

  }

  private void configureRenderer(MsSpectrumDataSet dataset, int datasetIndex) {

    final MsSpectrumType renderingType = dataset.getRenderingType();
    final XYPlot plot = chartNode.getChart().getXYPlot();

    // Set renderer
    AbstractXYItemRenderer newRenderer;
    switch (renderingType) {
      case PROFILE:
      case THRESHOLDED:
        XYLineAndShapeRenderer newLineRenderer = new XYLineAndShapeRenderer();
        final int lineThickness = dataset.getLineThickness();
        newLineRenderer.setBaseShape(new Ellipse2D.Double(-2 * lineThickness, -2 * lineThickness,
            4 * lineThickness + 1, 4 * lineThickness + 1));
        newLineRenderer.setBaseShapesFilled(true);
        newLineRenderer.setBaseShapesVisible(dataset.getShowDataPoints());
        newLineRenderer.setDrawOutlines(false);

        Stroke baseStroke = new BasicStroke(lineThickness);
        newLineRenderer.setBaseStroke(baseStroke);
        newRenderer = newLineRenderer;
        break;
      case CENTROIDED:
      default:
        XYBarRenderer newBarRenderer = new XYBarRenderer();
        // Avoid gradients
        newBarRenderer.setBarPainter(new StandardXYBarPainter());
        newBarRenderer.setShadowVisible(false);
        newRenderer = newBarRenderer;
        break;
    }

    // Set tooltips for legend
    newRenderer.setLegendItemToolTipGenerator((ds, series) -> {
      if (ds instanceof MsSpectrumDataSet) {
        return ((MsSpectrumDataSet) ds).getDescription();
      } else
        return null;
    });

    // Set color
    Color baseColor = dataset.getColor();
    newRenderer.setBasePaint(JavaFXUtil.convertColorToAWT(baseColor));

    // Set label generator
    XYItemLabelGenerator intelligentLabelGenerator =
        new IntelligentItemLabelGenerator(chartNode, 100, dataset);
    newRenderer.setBaseItemLabelGenerator(intelligentLabelGenerator);
    newRenderer.setBaseItemLabelPaint(JavaFXUtil.convertColorToAWT(labelsColor));
    newRenderer.setBaseItemLabelsVisible(itemLabelsVisible.get());

    // Set tooltip generator
    newRenderer.setBaseToolTipGenerator(dataset);

    plot.setRenderer(datasetIndex, newRenderer);

  }

  public void handleAddScan(Event e) {
    ParameterSet parameters =
        MZmineCore.getConfiguration().getModuleParameters(MsSpectrumPlotModule.class);
    ButtonType exitCode = parameters.showSetupDialog("Add scan");
    if (exitCode != ButtonType.OK)
      return;

    final RawDataFilesSelection fileSelection =
        parameters.getParameter(MsSpectrumPlotParameters.inputFiles).getValue();
    final Integer scanNumber =
        parameters.getParameter(MsSpectrumPlotParameters.scanNumber).getValue();
    final ScanSelection scanSelection =
        new ScanSelection(Range.singleton(scanNumber), null, null, null, null, null);
    final List<RawDataFile> dataFiles = fileSelection.getMatchingRawDataFiles();
    boolean spectrumAdded = false;
    for (RawDataFile dataFile : dataFiles) {
      for (MsScan scan : scanSelection.getMatchingScans(dataFile)) {
        String title = MsScanUtils.createSingleLineMsScanDescription(scan);
        addSpectrum(scan, title);
        spectrumAdded = true;
      }
    }
    if (!spectrumAdded) {
      MZmineGUI.displayMessage("Scan not found");
    }
  }

  public void handleAddSpectrumFromText(Event e) {
    ParameterSet parameters =
        MZmineCore.getConfiguration().getModuleParameters(SpectrumParserPlotModule.class);
    ButtonType exitCode = parameters.showSetupDialog("Parse spectrum");
    if (exitCode != ButtonType.OK)
      return;

    final String spectrumText =
        parameters.getParameter(SpectrumParserPlotParameters.spectrumText).getValue();
    final MsSpectrumType spectrumType =
        parameters.getParameter(SpectrumParserPlotParameters.spectrumType).getValue();

    Preconditions.checkNotNull(spectrumText);
    Preconditions.checkNotNull(spectrumType);

    final MsSpectrum spectrum = TxtImportAlgorithm.parseMsSpectrum(spectrumText);
    spectrum.setSpectrumType(spectrumType);

    String spectrumName = "Manual spectrum";

    addSpectrum(spectrum, spectrumName);
  }

  public void handleAddIsotopePattern(Event e) {
    ParameterSet parameters =
        MZmineCore.getConfiguration().getModuleParameters(IsotopePatternPlotModule.class);
    ButtonType exitCode = parameters.showSetupDialog("Add isotope pattern");
    if (exitCode != ButtonType.OK)
      return;
    final String formula = parameters.getParameter(IsotopePatternPlotParameters.formula).getValue();
    final Double mzTolerance =
        parameters.getParameter(IsotopePatternPlotParameters.mzTolerance).getValue();
    final Double minAbundance =
        parameters.getParameter(IsotopePatternPlotParameters.minAbundance).getValue();
    final Double normalizedIntensity =
        parameters.getParameter(IsotopePatternPlotParameters.normalizedIntensity).getValue();
    final MsSpectrum pattern = IsotopePatternGeneratorAlgorithm.generateIsotopes(formula,
        minAbundance, normalizedIntensity.floatValue(), mzTolerance);
    addSpectrum(pattern, formula);
  }

  public void handlePreviousScan(Event e) {
    for (MsSpectrumDataSet dataset : datasets) {
      MsSpectrum spectrum = dataset.getSpectrum();
      if (!(spectrum instanceof MsScan))
        continue;
      MsScan scan = (MsScan) spectrum;
      RawDataFile rawFile = scan.getRawDataFile();
      if (rawFile == null)
        return;
      int scanIndex = rawFile.getScans().indexOf(scan);
      if (scanIndex <= 0)
        return;
      MsScan prevScan = rawFile.getScans().get(scanIndex - 1);
      String title = MsScanUtils.createSingleLineMsScanDescription(prevScan);
      dataset.setSpectrum(prevScan, title);
    }
  }

  public void handleNextScan(Event e) {
    for (MsSpectrumDataSet dataset : datasets) {
      MsSpectrum spectrum = dataset.getSpectrum();
      if (!(spectrum instanceof MsScan))
        continue;
      MsScan scan = (MsScan) spectrum;
      RawDataFile rawFile = scan.getRawDataFile();
      if (rawFile == null)
        return;
      int scanIndex = rawFile.getScans().indexOf(scan);
      if (scanIndex == rawFile.getScans().size() - 1)
        return;
      MsScan nextScan = rawFile.getScans().get(scanIndex + 1);
      String title = MsScanUtils.createSingleLineMsScanDescription(nextScan);
      dataset.setSpectrum(nextScan, title);
    }
  }

  public void handleChartKeyPressed(KeyEvent e) {
    final KeyCode key = e.getCode();
    switch (key) {
      case RIGHT:
        handleNextScan(e);
        e.consume();
        break;
      case LEFT:
        handlePreviousScan(e);
        e.consume();
        break;
      case F:
        handleZoomOut(e);
        e.consume();
        break;
      case M:
        handleManualZoom(e);
        e.consume();
        break;
      case S:
        handleSetupLayers(e);
        e.consume();
        break;
      default:
    }

  }

  public void handleChartMousePressed(Event e) {
    chartNode.requestFocus();
  }

  public void handleSetupLayers(Event event) {
    try {
      URL layersDialogFXML = getClass().getResource(LAYERS_DIALOG_FXML);
      FXMLLoader loader = new FXMLLoader(layersDialogFXML);
      Stage layersDialog = loader.load();
      MsSpectrumLayersDialogController controller = loader.getController();
      controller.configure(datasets, this);
      layersDialog.initModality(Modality.APPLICATION_MODAL);
      layersDialog.show();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  public void handleToggleLabels(Event event) {
    itemLabelsVisible.set(!itemLabelsVisible.get());
  }

  public void handleToggleLegend(Event event) {
    legendVisible.set(!legendVisible.get());
  }

  public void handleContextMenuShowing(ContextMenuEvent event) {

    // Calculate the m/z value of the clicked point
    final double clickedX = event.getX();
    XYPlot plot = chartNode.getChart().getXYPlot();
    Rectangle2D chartArea = chartNode.getRenderingInfo().getPlotInfo().getDataArea();
    RectangleEdge axisEdge = plot.getDomainAxisEdge();
    ValueAxis domainAxis = plot.getDomainAxis();
    final double clickedMz = domainAxis.java2DToValue(clickedX, chartArea, axisEdge);
    final double clickedMzWithShift = Math.abs(clickedMz - mzShift.get());

    // Update the m/z shift menu item
    DecimalFormat mzFormat = MZmineCore.getConfiguration().getMZFormat();
    setToMenuItem.setText("Set to " + mzFormat.format(clickedMz) + " m/z");
    setToMenuItem.setUserData(clickedMz);

    // Update the Show XIC menu item
    showXICMenuItem.setText("Show XIC of " + mzFormat.format(clickedMzWithShift) + " m/z");
    showXICMenuItem.setUserData(clickedMzWithShift);

    // Update the MS/MS menu
    findMSMSMenu.setText("Find MS/MS of " + mzFormat.format(clickedMzWithShift) + " m/z");
    final ObservableList<MenuItem> msmsItems = findMSMSMenu.getItems();
    msmsItems.clear();
    MZmineProject project = MZmineCore.getCurrentProject();
    for (RawDataFile file : project.getRawDataFiles()) {
      scans: for (MsScan scan : file.getScans()) {
        if (scan.getMsFunction().getMsLevel() == 1)
          continue;
        for (IsolationInfo isolation : scan.getIsolations()) {
          if (!isolation.getIsolationMzRange().contains(clickedMzWithShift))
            continue;
          String menuLabel = MsScanUtils.createSingleLineMsScanDescription(scan, isolation);
          MenuItem msmsItem = new MenuItem(menuLabel);
          msmsItem.setOnAction(e -> MsSpectrumPlotModule.showNewSpectrumWindow(scan));
          msmsItems.add(msmsItem);
          continue scans;
        }
      }
    }
    if (msmsItems.isEmpty()) {
      MenuItem noneItem = new MenuItem("None");
      noneItem.setDisable(true);
      msmsItems.add(noneItem);
    }

    // Update the Remove... menu
    final ObservableList<MenuItem> rmItems = removeDatasetMenu.getItems();
    rmItems.clear();
    for (MsSpectrumDataSet dataset : datasets) {
      MenuItem msmsItem = new MenuItem(dataset.getName());
      msmsItem.setOnAction(e -> datasets.remove(dataset));
      rmItems.add(msmsItem);
    }
    removeDatasetMenu.setDisable(rmItems.isEmpty());

  }

  public void handleShowXIC(Event event) {
    Double xicMz = (Double) showXICMenuItem.getUserData();
    if (xicMz == null)
      return;

    // Collect all displayed raw data files
    List<RawDataFile> rawDataFiles = new ArrayList<>();
    for (MsSpectrumDataSet dataset : datasets) {
      if (dataset.getSpectrum() instanceof MsScan) {
        MsScan scan = (MsScan) dataset.getSpectrum();
        RawDataFile rawFile = scan.getRawDataFile();
        if (rawFile != null)
          rawDataFiles.add(rawFile);
      }
    }

    ParameterSet chromatogramParams =
        MZmineCore.getConfiguration().getModuleParameters(ChromatogramPlotModule.class);
    chromatogramParams.getParameter(ChromatogramPlotParameters.mzRange)
        .setValue(Range.closed(xicMz - 0.005, xicMz + 0.005));
    if (!rawDataFiles.isEmpty()) {
      chromatogramParams.getParameter(ChromatogramPlotParameters.inputFiles)
          .setValue(new RawDataFilesSelection(rawDataFiles));
    }
    chromatogramParams.showSetupDialog("Show XIC");

  }

  public void handleSetMzShiftTo(Event event) {
    Double newMzShift = (Double) setToMenuItem.getUserData();
    if (newMzShift == null)
      return;
    mzShift.set(newMzShift);
  }

  public void handleSetMzShiftManually(Event event) {
    DecimalFormat mzFormat = MZmineCore.getConfiguration().getMZFormat();
    String newMzShiftString = "0.0";
    Double newMzShift = (Double) setToMenuItem.getUserData();
    if (newMzShift != null)
      newMzShiftString = mzFormat.format(newMzShift);
    TextInputDialog dialog = new TextInputDialog(newMzShiftString);
    dialog.setTitle("m/z shift");
    dialog.setHeaderText("Set m/z shift value");
    Optional<String> result = dialog.showAndWait();
    result.ifPresent(value -> {
      try {
        double newValue = Double.parseDouble(value);
        mzShift.set(newValue);
      } catch (Exception e) {
        e.printStackTrace();
      }
    });

  }

  public void handleResetMzShift(Event event) {
    mzShift.set(0.0);
  }

  public void handlePrint(Event event) {
    JFreeChartUtils.printChart(chartNode);
  }

  public void handleNormalizeIntensityScale(Event event) {
    for (MsSpectrumDataSet dataset : datasets) {
      dataset.setIntensityScale(100.0);
    }
  }

  public void handleResetIntensityScale(Event event) {
    for (MsSpectrumDataSet dataset : datasets) {
      dataset.resetIntensityScale();
    }
  }

  public void handleZoomOut(Event event) {
    XYPlot plot = chartNode.getChart().getXYPlot();
    plot.getDomainAxis().setAutoRange(true);
    plot.getRangeAxis().setAutoRange(true);
  }

  public void handleManualZoom(Event event) {
    XYPlot plot = chartNode.getChart().getXYPlot();
    Window parent = chartNode.getScene().getWindow();
    ManualZoomDialog dialog = new ManualZoomDialog(parent, plot);
    dialog.show();
  }

  public void handleCopyImage(Event event) {
    JFreeChartUtils.exportToClipboard(chartNode);
  }

  public void handleExportJPG(Event event) {
    JFreeChartUtils.showSaveDialog(chartNode, ImgFileType.JPG);
  }

  public void handleExportPNG(Event event) {
    JFreeChartUtils.showSaveDialog(chartNode, ImgFileType.PNG);
  }

  public void handleExportPDF(Event event) {
    JFreeChartUtils.showSaveDialog(chartNode, ImgFileType.PDF);
  }

  public void handleExportSVG(Event event) {
    JFreeChartUtils.showSaveDialog(chartNode, ImgFileType.SVG);
  }

  public void handleExportEMF(Event event) {
    JFreeChartUtils.showSaveDialog(chartNode, ImgFileType.EMF);
  }

  public void handleExportEPS(Event event) {
    JFreeChartUtils.showSaveDialog(chartNode, ImgFileType.EPS);
  }

  public void handleCopySpectra(Event event) {
    StringBuilder sb = new StringBuilder();
    for (MsSpectrumDataSet dataset : datasets) {
      MsSpectrum spectrum = dataset.getSpectrum();
      String spectrumString = TxtExportAlgorithm.spectrumToString(spectrum);
      String splash = SplashCalculationAlgorithm.calculateSplash(spectrum);
      sb.append("# ");
      sb.append(dataset.getName());
      sb.append("\n");
      sb.append("# SPLASH ID: ");
      sb.append(splash);
      sb.append("\n");
      sb.append(spectrumString);
      sb.append("\n");
    }
    final Clipboard clipboard = Clipboard.getSystemClipboard();
    final ClipboardContent content = new ClipboardContent();
    content.putString(sb.toString());
    clipboard.setContent(content);
  }

  public void handleCopySplash(Event event) {
    StringBuilder sb = new StringBuilder();
    for (MsSpectrumDataSet dataset : datasets) {
      MsSpectrum spectrum = dataset.getSpectrum();
      String splash = SplashCalculationAlgorithm.calculateSplash(spectrum);
      sb.append(dataset.getName());
      sb.append(" SPLASH ID: ");
      sb.append(splash);
      sb.append("\n");
    }
    final Clipboard clipboard = Clipboard.getSystemClipboard();
    final ClipboardContent content = new ClipboardContent();
    content.putString(sb.toString());
    clipboard.setContent(content);
  }

  public void handleExportMzML(Event event) {

    FileChooser fileChooser = new FileChooser();
    fileChooser.setTitle("Export to mzML");
    fileChooser.getExtensionFilters().add(new ExtensionFilter("mzML", "*.mzML"));

    // Remember last directory
    if (lastSaveDirectory != null && lastSaveDirectory.isDirectory())
      fileChooser.setInitialDirectory(lastSaveDirectory);

    // Show the file chooser
    File file = fileChooser.showSaveDialog(chartNode.getScene().getWindow());

    // If nothing was chosen, quit
    if (file == null)
      return;

    // Save the last open directory
    lastSaveDirectory = file.getParentFile();

    final List<MsSpectrum> spectra = new ArrayList<>();
    for (MsSpectrumDataSet dataset : datasets) {
      spectra.add(dataset.getSpectrum());
    }

    // Do the export in a new thread
    final File finalFile = file;

    new Thread(() -> {
      try {
        // Create a temporary raw data file
        DataPointStore tmpStore = DataPointStoreFactory.getMemoryDataStore();
        RawDataFile tmpRawFile =
            MSDKObjectBuilder.getRawDataFile("Exported spectra", null, FileType.UNKNOWN, tmpStore);
        int scanNum = 1;
        for (MsSpectrumDataSet dataset : datasets) {
          MsSpectrum spectrum = dataset.getSpectrum();
          MsScan newScan;
          if (spectrum instanceof MsScan) {
            newScan = MsScanUtil.clone(tmpStore, (MsScan) spectrum, true);
          } else {
            MsFunction msf = MSDKObjectBuilder.getMsFunction(MsFunction.DEFAULT_MS_FUNCTION_NAME);
            newScan = MSDKObjectBuilder.getMsScan(tmpStore, scanNum, msf);
          }
          tmpRawFile.addScan(newScan);
        }
        MzMLFileExportMethod exporter = new MzMLFileExportMethod(tmpRawFile, finalFile);
        exporter.execute();
        tmpRawFile.dispose();
      } catch (Exception e) {
        MZmineGUI.displayMessage("Unable to export: " + e.getMessage());
        e.printStackTrace();
      }
    }).start();

  }

  public void handleExportMGF(Event event) {

    FileChooser fileChooser = new FileChooser();
    fileChooser.setTitle("Export to MGF");
    fileChooser.getExtensionFilters()
        .add(new FileChooser.ExtensionFilter("Mascot Generic Format", "*.mgf"));

    // Remember last directory
    if (lastSaveDirectory != null && lastSaveDirectory.isDirectory())
      fileChooser.setInitialDirectory(lastSaveDirectory);

    // Show the file chooser
    File file = fileChooser.showSaveDialog(chartNode.getScene().getWindow());

    // If nothing was chosen, quit
    if (file == null)
      return;

    // Save the last open directory
    lastSaveDirectory = file.getParentFile();

    final List<MsSpectrum> spectra = new ArrayList<>();
    for (MsSpectrumDataSet dataset : datasets) {
      spectra.add(dataset.getSpectrum());
    }

    // Do the export in a new thread
    final File finalFile = file;
    new Thread(() -> {
      try {
        MgfFileExportMethod mgfEx = new MgfFileExportMethod(spectra, finalFile);
        mgfEx.execute();
      } catch (Exception e) {
        MZmineGUI.displayMessage("Unable to export: " + e.getMessage());
        e.printStackTrace();
      }
    }).start();
  }

  public void handleExportMSP(Event event) {
    FileChooser fileChooser = new FileChooser();
    fileChooser.setTitle("Export to MSP");
    fileChooser.getExtensionFilters().add(new ExtensionFilter("NIST MSP format", "*.msp"));

    // Remember last directory
    if (lastSaveDirectory != null && lastSaveDirectory.isDirectory())
      fileChooser.setInitialDirectory(lastSaveDirectory);

    // Show the file chooser
    File file = fileChooser.showSaveDialog(chartNode.getScene().getWindow());

    // If nothing was chosen, quit
    if (file == null)
      return;

    // Save the last open directory
    lastSaveDirectory = file.getParentFile();

    final List<MsSpectrum> spectra = new ArrayList<>();
    for (MsSpectrumDataSet dataset : datasets) {
      spectra.add(dataset.getSpectrum());
    }

    // Do the export in a new thread
    final File finalFile = file;
    new Thread(() -> {
      try {
        MspExportAlgorithm.exportSpectra(finalFile, spectra);
      } catch (Exception e) {
        MZmineGUI.displayMessage("Unable to export: " + e.getMessage());
        e.printStackTrace();
      }
    }).start();
  }

  public void handleExportTXT(Event event) {
    FileChooser fileChooser = new FileChooser();
    fileChooser.setTitle("Export to TXT");
    fileChooser.getExtensionFilters().add(new ExtensionFilter("TXT", "*.txt"));

    // Remember last directory
    if (lastSaveDirectory != null && lastSaveDirectory.isDirectory())
      fileChooser.setInitialDirectory(lastSaveDirectory);

    // Show the file chooser
    File file = fileChooser.showSaveDialog(chartNode.getScene().getWindow());

    // If nothing was chosen, quit
    if (file == null)
      return;

    // Save the last open directory
    lastSaveDirectory = file.getParentFile();

    final List<MsSpectrum> spectra = new ArrayList<>();
    for (MsSpectrumDataSet dataset : datasets) {
      spectra.add(dataset.getSpectrum());
    }

    // Do the export in a new thread
    final File finalFile = file;
    new Thread(() -> {
      try {
        TxtExportAlgorithm.exportSpectra(finalFile, spectra);
      } catch (Exception e) {
        MZmineGUI.displayMessage("Unable to export: " + e.getMessage());
        e.printStackTrace();
      }
    }).start();
  }

}