package SesameGUI;

import java.util.Vector;
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.text.NumberFormat;
import javax.swing.*;
import java.awt.event.KeyEvent;

public class SpectrumView extends javax.swing.JPanel
	{

	public SpectrumView()
		{
    showLegend = true;
    
		Action leftActionListener = new AbstractAction()
			{
			public void actionPerformed(ActionEvent actionEvent)
				{
				if (measuring)
					{
					if (measuringNdx >= 1)
						{
						measuringX -= ((Spectrum)spectra.get(measuringSpectra)).getSamplingRate();

						if (measuringX < scaleX.getLowerVisibleBound())
							{
							measuringX += ((Spectrum)spectra.get(measuringSpectra)).getSamplingRate();
							return;
							}

						measuringNdx--;
						repaint();
						}
					}
				}
			};

		Action enterActionListener = new AbstractAction()
			{
			public void actionPerformed(ActionEvent actionEvent)
				{
				if (measuring)
					{
					DoubleWrapper dw;
					dw = new DoubleWrapper();

					Spectrum sp;
					String s;

					sp = ((Spectrum)spectra.get(measuringSpectra));

					double x;
					dw.value = measuringX - scaleX.getLowerVisibleBound();
					scaleX.real2Pane(dw);
					x = dw.value;

					double offset;

					offset = scaleY.getOrigin() * (-1.0);

					dw.value = sp.valueAt(measuringNdx);
					NumberFormat formater = NumberFormat.getNumberInstance();
					formater.setMaximumFractionDigits(3);
					s = formater.format(measuringX) + " , " + formater.format(dw.value);

					sp.addSample(s);

					//           JOptionPane.showMessageDialog(null , s);
					}
				}
			};

		Action saveActionListener = new AbstractAction()
			{
			public void actionPerformed(ActionEvent actionEvent)
				{
				JFileChooser chooser = new JFileChooser();

				int returnVal = chooser.showSaveDialog(null);
				if (returnVal == JFileChooser.APPROVE_OPTION)
					{
					if (chooser.getSelectedFile().exists())
						{
						int ret;

						ret = JOptionPane.showConfirmDialog(null, "The file already exists. Do you want to delete it before writing the samples?");

						if (ret == JOptionPane.CANCEL_OPTION)
							return;

						if (ret == JOptionPane.YES_OPTION)
							chooser.getSelectedFile().delete();
						}

					Spectrum sp;

					sp = ((Spectrum)spectra.get(measuringSpectra));
					sp.saveSamples(chooser.getSelectedFile().getAbsolutePath());
					}
				}
			};

		Action rightActionListener = new AbstractAction()
			{
			public void actionPerformed(ActionEvent actionEvent)
				{
				if (measuring)
					{
					if (measuringNdx + 1 <= ((Spectrum)spectra.get(measuringSpectra)).getSize())
						{
						measuringX = ((Spectrum)spectra.get(measuringSpectra)).getSamplingRate() + measuringX;

						if (measuringX > scaleX.getUpperVisibleBound())
							{
							measuringX -= ((Spectrum)spectra.get(measuringSpectra)).getSamplingRate();
							return;
							}

						measuringNdx++;

						repaint();
						}
					}
				}
			};

    parentFrame = null;
		windowSelectionEnabled=false;
		selectingWindow = false;

		KeyStroke leftArrow = KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0, true);
		getInputMap().put(leftArrow, "actionLeft");
		getActionMap().put("actionLeft", leftActionListener);
		//  		addActionListener (leftArrow);

		KeyStroke rightArrow = KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0, true);
		getInputMap().put(rightArrow, "actionRight");
		getActionMap().put("actionRight", rightActionListener);

		KeyStroke enterKey = KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0, true);
		getInputMap().put(enterKey, "actionEnter");
		getActionMap().put("actionEnter", enterActionListener);

		KeyStroke saveKey = KeyStroke.getKeyStroke(KeyEvent.VK_F10, 0, true);
		getInputMap().put(saveKey, "actionSave");
		getActionMap().put("actionSave", saveActionListener);

        /*KeyStroke deleteKey = KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0, true);
		getInputMap().put(deleteKey, "actionDelete");
		getActionMap().put("actionDelete", deleteActionListener);*/
		addKeyListener(
		  new java.awt.event.KeyAdapter() {
		     public void keyTyped(java.awt.event.KeyEvent evt) {
		        System.out.println("keytyped");
		       if( evt.getKeyChar()== evt.VK_DELETE )
		         DeletedWindow(selectedWindow);
		     }
		  }
		);
		

		margins = false;

		selectedWindow = 0;

		measuring = false;

		scaleX = null;
		scaleY = null;
		spectra = new Vector();

		selectionStart = 0;
		selectionEnd = 0;
        windowLength = 10; // seconds
        spaceBetweenWindow = 2; //  seconds
		addMouseListener(
		    new java.awt.event.MouseAdapter()
			    {
			    public void mousePressed(java.awt.event.MouseEvent evt)
				    {
				    paneMousePressed(evt);
				    }
			    public void mouseReleased(java.awt.event.MouseEvent evt)
				    {
				    paneMouseReleased(evt);
				    }
			    });

		addMouseMotionListener(
		    new java.awt.event.MouseMotionAdapter()
			    {
			    public void mouseDragged(java.awt.event.MouseEvent evt)
				    {
				    onMouseDragged(evt);
				    }
			    });
		}

  public void setWindowLen (double wl)
    {
    window_len = wl;    
    }

  public void setF0 (double _F0 , double _F0_m_sd , double _F0_p_sd)
      {
      F0 = _F0;
      F0_m_sd = _F0_m_sd;
      F0_p_sd = _F0_p_sd;
      }

  public void EnableWindowSelection(boolean enable)
		{
    windowSelectionEnabled=enable;
    }

	public Scale getScaleX()
		{
		return scaleX;
		}

	public void setScaleX(Scale scaleX)
		{
		this.scaleX = scaleX;
		}

	public Scale getScaleY()
		{
		return scaleY;
		}

  public double getOrigOffset()
    {
    if (spectra.size() > 0)
      return ((Spectrum)spectra.get(0)).getOrigOffset();

    return 0;
    }

  public double getSamplingRate()
    {
    if (spectra.size() > 0)
      return ((Spectrum)spectra.get(0)).getSamplingRate();

    return 0;
    }

  public boolean isLog()
    {
    if (spectra.size() > 0)
      return ((Spectrum)spectra.get(0)).isLog();

    return false;
    }

	public void setScaleY(Scale scaleY)
		{
		this.scaleY = scaleY;
		}

  public double getTicker(int ndx)
		{
		if (spectra.size() > 0)
      return ((Spectrum)spectra.get(0)).getTickerAt(ndx);

    return 0.0;
		}

	public void paintComponent(Graphics g)
		{
		super.paintComponent(g);

    DoubleWrapper dw;
		dw = new DoubleWrapper();

		if (margins)
			{
			leftMargin = 60;
			bottomMargin = 40;
			rightMargin = getWidth() - 20;
			topMargin = getHeight() - 20;
			}
		else
			{
			leftMargin = 0;
			bottomMargin = 0;
			rightMargin = getWidth();
			topMargin = getHeight();
			}

		if (measuring && (!getScaleX().toString().equals("LogarithmicHorizontalScale")))
			{
			Spectrum sp;
			String s;

			sp = ((Spectrum)spectra.get(measuringSpectra));

			double x;
      int startingIndex;
      int ptIndex;

      startingIndex = (int)(scaleX.getLowerVisibleBound() / sp.getSamplingRate());

      if (startingIndex < 0)
        startingIndex = 0;

      ptIndex = (int)(measuringX / sp.getSamplingRate());
      ptIndex--;
      
      if (ptIndex < 0)
        ptIndex = 0;

      measuringX = measuringNdx * sp.getSamplingRate();

      if (isLog())
        measuringX = getTicker(measuringNdx);
      
      dw.value = ((measuringNdx - 1) - startingIndex) * sp.getSamplingRate();
			scaleX.real2Pane(dw);
			x = dw.value;

			double offset;

			offset = scaleY.getOrigin() * (-1.0);

      if (scaleY.toString().equals("LogarithmicVerticalScale"))
        offset = 0.0;

			NumberFormat formater = NumberFormat.getNumberInstance();
			formater.setMaximumFractionDigits(3);
      dw.value = sp.valueAt(measuringNdx) + offset;

      if (isLog())
        {
        s = formater.format(measuringX) + " , " + formater.format(dw.value - offset);
        }
      else
        {
        if (getParentPanel() == null)
          s = formater.format(measuringX + getOrigOffset()) + " , " + formater.format(dw.value - offset);
        else
          s = formater.format((measuringX  / getSpectrum(0).getSamplingRate() / getSpectrum(0).getSamplingRate()) + getOrigOffset()) + " , " + formater.format(dw.value - offset);
        }

			scaleY.real2Pane(dw);

			((Graphics2D)g).setPaint(new Color(0, 0, 0));
			((Graphics2D)g).drawString(s, (float)(x + 15.0), (float)(getHeight() - dw.value));

			((Graphics2D)g).scale(1.0, -1.0);
			((Graphics2D)g).translate(0.0, (getHeight() - 1.0) * -1.0);

      ((Graphics2D)g).setPaint(new Color(255, 255, 174, 200));
			((Graphics2D)g).fill(new Ellipse2D.Double(x - 10.0, (dw.value - 10.0), 20.0, 20.0));
			}
		else
			{
			((Graphics2D)g).scale(1.0, -1.0);
			((Graphics2D)g).translate(0.0, (getHeight() - 1.0) * -1.0);
			}

		int i;

		if (scaleX == null)
			return;

		scaleX.draw((Graphics2D)g);
		scaleY.draw((Graphics2D)g);

    g.setClip(leftMargin , bottomMargin , rightMargin - leftMargin , topMargin - bottomMargin);
    
		for (i = 0; i < spectra.size(); i++)
			{
			((Spectrum)spectra.get(i)).draw((Graphics2D)g, this, selectedWindow);
			}

		double s;
		double f;

		if (selectionEnd < selectionStart)
			{
			f = selectionStart;
			s = selectionEnd;
			}
		else
			{
			s = selectionStart;
			f = selectionEnd;
			}

    if (window_len != 0.0)
      {
      double    m;
      ((Graphics2D)g).setPaint(new Color(255, 127, 127 , 100));

      if (getScaleX().toString().equals("LogarithmicHorizontalScale"))
        dw.value = (10.0 / window_len) - (scaleX.getOrigOffset() + scaleX.getOrigin());
      else
        {
        dw.value = (10.0 / window_len) - scaleX.getOrigin();

        if (dw.value < scaleX.getLowerVisibleBound())
          dw.value = 0.0;
        }

      scaleX.real2Pane(dw);
			m = dw.value;

      ((Graphics2D)g).fill(new Rectangle2D.Double(getLeftMargin() , getBottomMargin(), m - getLeftMargin() , getTopMargin() - getBottomMargin()));

      ((Graphics2D)g).setPaint(new Color(255, 127, 127));
      ((Graphics2D)g).draw(new Rectangle2D.Double(getLeftMargin() , getBottomMargin(), m - getLeftMargin() , getTopMargin() - getBottomMargin()));
      }

    if (F0 > 0.0)
      {
      double    m , p , f0;
      ((Graphics2D)g).setPaint(new Color(192, 192, 192 , 100));

      if (getScaleX().toString().equals("LogarithmicHorizontalScale"))
        {
        dw.value = F0_m_sd - (scaleX.getOrigOffset() + scaleX.getOrigin());
        scaleX.real2Pane(dw);
    		m = dw.value;

        dw.value = F0_p_sd - (scaleX.getOrigOffset() + scaleX.getOrigin());
        scaleX.real2Pane(dw);
  			p = dw.value;

        dw.value = F0 - (scaleX.getOrigOffset() + scaleX.getOrigin());
        scaleX.real2Pane(dw);
      	f0 = dw.value;
        }
      else
        {
        dw.value = F0_m_sd - (scaleX.getOrigin() + scaleX.getLowerVisibleBound());
        scaleX.real2Pane(dw);
    		m = dw.value;

        dw.value = F0_p_sd - (scaleX.getOrigin() + scaleX.getLowerVisibleBound());
        scaleX.real2Pane(dw);
  			p = dw.value;

        dw.value = F0 - (scaleX.getOrigin() + scaleX.getLowerVisibleBound());
        scaleX.real2Pane(dw);
      	f0 = dw.value;
        }

      ((Graphics2D)g).fill(new Rectangle2D.Double(m , getBottomMargin(), p - m , getTopMargin() - getBottomMargin()));

      ((Graphics2D)g).setPaint(new Color(192, 192, 192));
			((Graphics2D)g).draw(new Rectangle2D.Double(m , getBottomMargin(), f0 - m , getTopMargin() - getBottomMargin()));
      ((Graphics2D)g).draw(new Rectangle2D.Double(f0 , getBottomMargin(), p - f0 , getTopMargin() - getBottomMargin()));
      }

		if (f != s)
			{
			((Graphics2D)g).setPaint(new Color(255, 255, 174, 200));
			((Graphics2D)g).fill(new Rectangle2D.Double(s, getBottomMargin(), f - s, getTopMargin() - getBottomMargin()));
			((Graphics2D)g).setPaint(new Color(242, 242, 0));
			((Graphics2D)g).draw(new Rectangle2D.Double(s, getBottomMargin(), f - s, getTopMargin() - getBottomMargin()));
			}

    g.setClip(0 , 0 , getWidth() , getHeight());

    ((Graphics2D)g).draw(new Line2D.Double(0, 1, getWidth() , 1));

    drawLegend (g);
		}

	public void addSpectrum(Spectrum spectrum)
		{
		if (spectrum != null)
			{
			spectrum.initializeScale(scaleX, scaleY, true);
			spectra.add(spectrum);
			}
		else
			{
			spectra.clear ();
			}	
		}

	public int getLeftMargin()
		{
		return leftMargin;
		}

	public void setLeftMargin(int leftMargin)
		{
		this.leftMargin = leftMargin;
		}

	public int getRightMargin()
		{
		return rightMargin;
		}

	public void setRightMargin(int rightMargin)
		{
		this.rightMargin = rightMargin;
		}

	public int getTopMargin()
		{
		return topMargin;
		}

	public void setTopMargin(int topMargin)
		{
		this.topMargin = topMargin;
		}

	public int getBottomMargin()
		{
		return bottomMargin;
		}

	public void setBottomMargin(int bottomMargin)
		{
		this.bottomMargin = bottomMargin;
		}

    public void setWindowLength(double val) {
        windowLength=val;
    }
    
	private void paneMousePressed(java.awt.event.MouseEvent evt)
		{
		measuring = false;

		if (evt.getModifiers() == java.awt.event.MouseEvent.BUTTON1_MASK)
			{
      if (windowSelectionEnabled)
                selectingWindow = true;
			else
                selecting = true;

			selectionStart = evt.getPoint().getX();
			}
		else
			{
			if (SwingUtilities.isMiddleMouseButton(evt))
				{
				DoubleWrapper dw = new DoubleWrapper();
				double x, y;

				dw.value = evt.getPoint().getX() - leftMargin;
				scaleX.pane2Real(dw);
				x = dw.value;

				dw.value = (getHeight() - evt.getPoint().getY()) - bottomMargin;
				scaleY.pane2Real(dw);
				y = dw.value;

				int ndx;
				int spec;
				double yDist;
				int tmpNdx;

				spec = 0;
				yDist = 99999999.0;
				ndx = -1;

				for (int i = 0; i < spectra.size(); i++)
					{
					Spectrum sp;

					sp = ((Spectrum)spectra.get(i));

					tmpNdx = sp.indexOf(x, this);

					if (tmpNdx >= 0)
						{
						if (Math.abs(y - sp.valueAt(tmpNdx)) < yDist)
							{
							ndx = tmpNdx;
							spec = i;
							yDist = Math.abs(y - sp.valueAt(ndx));
							}
						}
					}

				if (ndx >= 0)
					{
					measuring = true;
					measuringNdx = ndx + 1;
					measuringSpectra = spec;
          
					measuringX = ((Spectrum)spectra.get(spec)).normalizeCoord(x, this) + ((Spectrum)spectra.get(spec)).getSamplingRate();

					requestFocus();

					repaint();
					}
				}
			}
		}

	private void paneMouseReleased(java.awt.event.MouseEvent evt)
		{
		if (evt.getModifiers() == java.awt.event.MouseEvent.BUTTON1_MASK)
			{
			if (selecting)
				{
				selectionEnd = evt.getPoint().getX();

				normalizeSelection();

				if (selectionEnd - selectionStart <= 1.0 || getScaleX().toString().equals("LogarithmicHorizontalScale"))
					{
					scaleX.setLowerVisibleBound(scaleX.getLowerBound());
					scaleX.setUpperVisibleBound(scaleX.getUpperBound());

					selectionStart = 0;
					selectionEnd = 0;
					}
				else
					{
          // zoom
					DoubleWrapper indexStart;
					DoubleWrapper indexEnd;

          indexStart = new DoubleWrapper();
					indexEnd = new DoubleWrapper();

					indexStart.value = selectionStart - leftMargin;
					indexEnd.value = selectionEnd - leftMargin;

					scaleX.pane2Real(indexStart);
					scaleX.pane2Real(indexEnd);

          if (indexStart.value < scaleX.getLowerBound())
            indexStart.value = scaleX.getLowerBound();

          if (indexEnd.value > scaleX.getUpperBound())
            indexEnd.value = scaleX.getUpperBound();

					scaleX.setLowerVisibleBound(indexStart.value);
					scaleX.setUpperVisibleBound(indexEnd.value);

					selectionStart = 0;
					selectionEnd = 0;
					}

				if (parentPanel != null)
					parentPanel.repaintNotify();
				else
					repaint();
				}
			else if (selectingWindow)
				{
                selectionEnd = evt.getPoint().getX();

				normalizeSelection();

				if (selectionEnd - selectionStart <= 1.0)
					{
					selectionStart = 0;
					selectionEnd = 0;
					}
				else
					{
					DoubleWrapper indexStart;
					DoubleWrapper indexEnd;

					indexStart = new DoubleWrapper();
					indexEnd = new DoubleWrapper();

					indexStart.value = selectionStart - leftMargin;
					indexEnd.value = selectionEnd - leftMargin;

					scaleX.pane2Real(indexStart);
					scaleX.pane2Real(indexEnd);
                    SelectedRange(indexStart.value , indexEnd.value);
                	}
				}

			selecting = false;
			selectingWindow = false;
			}
		else if (evt.getModifiers() == java.awt.event.MouseEvent.BUTTON3_MASK)
			{
			DoubleWrapper x;

			x = new DoubleWrapper();
			x.value = evt.getPoint().getX();

			scaleX.pane2Real(x);

			int selectedWindowPrevious = ((Spectrum)spectra.get(0)).selectWindow(x.value);
			if (selectedWindowPrevious>0) {
             if( selectedWindowPrevious==selectedWindow) {
              Object[] options = { "YES", "NO" }; 
              int answer = JOptionPane.showOptionDialog(null, "Are you sure do you want to delete this window", 
                 "Warning", JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, null, options, options[0]);       
              if(answer==0) {
                DeletedWindow(selectedWindow);
                selectedWindowPrevious=0;
                restartplot();
              }
             }
             selectedWindow=selectedWindowPrevious;

            if (parentPanel != null)
               parentPanel.selectedWindow(selectedWindow);
            }
			/*if (selectedWindow > 0)
				{
				if (parentPanel != null)
					parentPanel.selectedWindow(selectedWindow);
				else
					repaint();
				}*/
			  
			}
		}

	private void normalizeSelection()
		{
		if (selectionEnd < selectionStart)
			{
			double tmp;
			tmp = selectionStart;
			selectionStart = selectionEnd;
			selectionEnd = tmp;
			}
		}

	private void onMouseDragged(java.awt.event.MouseEvent evt)
		{
		if (selecting || selectingWindow)
			{
			selectionEnd = evt.getPoint().getX();

			Rectangle r = new Rectangle();

			getBounds(r);

			if (selectionEnd < selectionStart)
				repaint((int)selectionEnd - 60, 0, (int)(selectionStart - selectionEnd) + 60, r.height);
			else
				repaint((int)selectionStart, 0, (int)(selectionEnd - selectionStart) + 60, r.height);
			}
		}

	public PreviewWavePanel getParentPanel()
		{
		return parentPanel;
		}

	public void setParentPanel(PreviewWavePanel parent)
		{
		this.parentPanel = parent;
		}

	public boolean isMargins()
		{
		return margins;
		}

	public void setMargins(boolean margins)
		{
		this.margins = margins;
		}

	public int getSelectedWindow()
		{
		return selectedWindow;
		}

	public void setSelectedWindow(int selectedWindow)
		{
		this.selectedWindow = selectedWindow;
		}

	public void removeSpectra()
		{
		spectra.removeAllElements();
		}
		
	public void setSpaceBetweenWindows(double sec) {
	    spaceBetweenWindow=sec;
	}
	
    private void restartplot() {
        scaleX.setLowerVisibleBound(scaleX.getLowerBound());
		scaleX.setUpperVisibleBound(scaleX.getUpperBound());
		selectionStart = 0;
		selectionEnd = 0;
    if (parentPanel != null)
			parentPanel.repaintNotify();
    else
     	  repaint();
    }
    
	public void SelectedRange(double startSecond , double endSecond)
		{
		 double secDif = endSecond - startSecond;
		 double startSec,endSec;
		 double space = spaceBetweenWindow*(this.getSamplingRate()*this.getSamplingRate());
		 int numWind = (int)((secDif)/(windowLength*(this.getSamplingRate()*this.getSamplingRate())));
		 if(numWind == 0) ++numWind;
         Spectrum sp = (Spectrum)spectra.get(0);
         int i;
         startSec=startSecond;
         for (i = 0; i< numWind; ++i) {
          endSec = startSec + (windowLength*(this.getSamplingRate()*this.getSamplingRate()));
          sp.getWindows().add(startSec, endSec);
          int j = sp.getWindows().getNumberWindows();
          sp.getWindows().get(j).setAutoWindow(false);
          startSec = endSec + space;
         }
         restartplot();
         parentFrame.setWindows(getWindows(),parentFrame.ACTIVE_OBJECT_PLOTED,false);
		}

	public void DeletedWindow (int windowNdx)
		{
        if (windowNdx > 0)
			{
			Spectrum sp = (Spectrum)spectra.get(0);
			sp.getWindows().remove(windowNdx);
			parentFrame.setWindows(getWindows(),parentFrame.ACTIVE_OBJECT_PLOTED,false);
			}
		}
	
	public Spectrum getSpectrum() {
	    return getSpectrum(0);
	}

  	public Spectrum getSpectrum(int ndx) {
      if (ndx < getSpectrumCount ())
  	    return (Spectrum)spectra.get(ndx);

      return null;
	}

  public int getSpectrumCount ()
  {
    return spectra.size();
  }
	
	public Windows getWindows() {
	   	Spectrum sp = (Spectrum)spectra.get(0);
		return sp.getWindows();
	}

    public void setFrame(JFrameSesame frame) {
        parentFrame = frame;       
    }

  public void setShowLegend(boolean l)
  {
    showLegend = l;
  }

  public boolean getShowLegend()
  {
    return showLegend;
  }

  public void drawLegend(Graphics g)
  {
    int         legSize = 25;
    
    if (!showLegend)
      return;

    ((Graphics2D)g).setPaint(Color.white);
    ((Graphics2D) g).fillRect(getWidth() - 155 , getHeight() - 5 - (legSize * spectra.size()) , 150 , legSize * spectra.size());
    ((Graphics2D)g).setPaint(Color.black);
    ((Graphics2D) g).drawRect(getWidth() - 155 , getHeight() - 5 - (legSize * spectra.size()) , 150 , legSize * spectra.size());

    int     i;
    int     pos;

    pos = getHeight() - 5;
    
    for (i = 0; i < spectra.size(); i++)
			{
			((Spectrum)spectra.get(i)).drawLegend((Graphics2D)g, this, getWidth() - 150 , pos , legSize);

                        pos -= legSize;
			}
  }
     
	private Scale scaleX;
	private Scale scaleY;

	/** @associates <{SesameGUI.Spectrum}> */
	private Vector spectra;
	private int leftMargin;
	private int rightMargin;
	private int topMargin;
	private int bottomMargin;
	private double selectionStart;
	private double selectionEnd;
	private boolean selecting;
  private boolean selectingWindow;
	private PreviewWavePanel parentPanel;
	private boolean margins;
	private int selectedWindow;
	private boolean measuring;
	private double measuringX;
	private int measuringNdx;
	private int measuringSpectra;
	private ScaleVisualProperties scaleXProperties;
	private ScaleVisualProperties scaleYProperties;
  private double windowLength;
  private boolean windowSelectionEnabled;
  private double spaceBetweenWindow;
  private JFrameSesame parentFrame;
  private boolean showLegend;
  private double F0;
  private double F0_m_sd;
  private double F0_p_sd;

  private double window_len;
	}