/* JRG, the Resource Geology Seismic Processing System for Java,
   and Viewmat for Java are Copyright 1998-2006 by John N. Louie

The software and methods here are the subject of academic research,
not commercial products. I would like to know what use you make of
my methods, and have your feedback on their success or failure.
Also, by letting me know who you are, I can inform you if bugs or
errors are discovered.
 
Please send me an email message with: your name and email address;
whether you are a student or faculty member, consultant or employee;
the name of your university or company, and department; and a sentence
or two describing what use you intend to make of these methods.
Send your message to louie@seismo.unr.edu */


import java.io.*;
import java.util.Vector;
import java.awt.*;
import java.awt.event.*;

public class ViewmatFrame extends Frame 
	implements ActionListener/*, ItemListener*/
	{
	static int nextx=0, nexty=0;
	static Vector framelist=null;
	Menu Windows;
	Viewmat vm;
	Viewmat vms[];
	FileDialog fd;
	ViewmatProps props;
	ViewmatPicks picks;
	ViewmatGeom geom;
	String path;
	int plane;
	
	public void actionPerformed(ActionEvent e)
		{
		String label = e.getActionCommand();
		String menuname;
		if (e.getSource() instanceof Menu)
			menuname = ((Menu)e.getSource()).getLabel();
		else
			menuname = "Not a menu action.";
		if (menuname.equals("On Whole Data Set"))
			{
			FltVec.handleMethod(this, vm.inplace.getState(), label);
			vm.resetPropsPanel(props, props.pp);
			vm.setParameters(props, props.pp);
			redoWindowMenu();
			System.gc();
			return;
			}
		else if (menuname.equals("On Each Vector"))
			{
			FltPlane.handleMethod(this, vm.inplace.getState(), label);
			vm.resetPropsPanel(props, props.pp);
			vm.setParameters(props, props.pp);
			redoWindowMenu();
			System.gc();
			return;
			}
		else if (menuname.equals("On Each Plane"))
			{
			FltVol.handleMethod(this, vm.inplace.getState(), label);
			vm.resetPropsPanel(props, props.pp);
			vm.setParameters(props, props.pp);
			redoWindowMenu();
			System.gc();
			return;
			}
		else if (menuname.equals("Windows"))
			{
			for (int i=0; i<framelist.size(); i++)
				{
				if (label.equals(((ViewmatFrame)(framelist.elementAt(i))).getTitle()))
					{
					((ViewmatFrame)(framelist.elementAt(i))).show();
					break;
					}
				}
			return;
			}
		
		if (label.equals("Close Window"))
			{
			disposePlot();
			}
		else if (label.equals("Exit Java"))
			System.exit(0);
		else if (label.equals("Open Binary File..."))
			{
			setCursor(Cursor.WAIT_CURSOR);
			handleOpenBinary();
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("Write Binary File..."))
			{
			setCursor(Cursor.WAIT_CURSOR);
			handleWriteBinary(false);
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("Append to Binary File..."))
			{
			setCursor(Cursor.WAIT_CURSOR);
			handleWriteBinary(true);
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("Write Sound File..."))
			{
			setCursor(Cursor.WAIT_CURSOR);
			handleWriteSound();
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("Write Ascii File..."))
			{
			setCursor(Cursor.WAIT_CURSOR);
			handleWriteASCII();
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("Write PostScript File..."))
			{
			fd.setMode(FileDialog.SAVE);
			if (vm.fvol == null)
				{
				fd.setTitle("Write Plane to PostScript File...");
				fd.setFile(titleforfile(this.getTitle()) + ".ps");
				}
			else
				{
				plane = vm.cvs.plane;
				fd.setTitle("Write Plane " + plane + " to PostScript File...");
				fd.setFile(titleforfile(this.getTitle()) + plane + ".ps");
				}
			centerComp(fd);
			fd.show();
			if (fd.getFile() != null)
				{
				setCursor(Cursor.WAIT_CURSOR);
				path = fd.getDirectory() + fd.getFile();
				if (vm.fvol == null)
					/* altered 4/10/06 JNL to workaround MacOS 10.4 bug
					   thanks to Leiph Preston!
					new Thread (new createPSFileRun(vm, path)).start();
					*/
					(new createPSFileRun(vm, path)).run();
				else
					/* altered 4/10/06 JNL to workaround MacOS 10.4 bug
					   thanks to Leiph Preston!
					new Thread (new createPSFileRun(vms[plane], path, plane)).start();
					*/
					(new createPSFileRun(vms[plane], path, plane)).run();
				setCursor(Cursor.DEFAULT_CURSOR);
				}
			}
		else if (label.equals("Plot Parameters..."))
			{
			setCursor(Cursor.WAIT_CURSOR);
			sideComp(props);
			props.show();
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("Apply Parameter File..."))
			{
			setCursor(Cursor.WAIT_CURSOR);
			props.openProperties();
			if (fd.getFile() == null)
				{
				setCursor(Cursor.DEFAULT_CURSOR);
				return;
				}
			props.applyChanges();
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("Clip at Maximum"))
			{
			setCursor(Cursor.WAIT_CURSOR);
			this.vm.cliptf.setText("max");
			props.applyChanges();
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("Clip at RMS"))
			{
			setCursor(Cursor.WAIT_CURSOR);
			this.vm.cliptf.setText("rms");
			props.applyChanges();
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("Clip at 3*RMS"))
			{
			setCursor(Cursor.WAIT_CURSOR);
			this.vm.cliptf.setText("3*rms");
			props.applyChanges();
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("1 to 1"))
			{
			setCursor(Cursor.WAIT_CURSOR);
			this.vm.ve = 1F;
			this.vm.vetf.setText("1.0");
			props.applyChanges();
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("x2"))
			{
			setCursor(Cursor.WAIT_CURSOR);
			this.vm.ve *= 2F;
			this.vm.vetf.setText("" + this.vm.ve);
			props.applyChanges();
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("x5"))
			{
			setCursor(Cursor.WAIT_CURSOR);
			this.vm.ve *= 5F;
			this.vm.vetf.setText("" + this.vm.ve);
			props.applyChanges();
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("x10"))
			{
			setCursor(Cursor.WAIT_CURSOR);
			this.vm.ve *= 10F;
			this.vm.vetf.setText("" + this.vm.ve);
			props.applyChanges();
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("/2"))
			{
			setCursor(Cursor.WAIT_CURSOR);
			this.vm.ve /= 2F;
			this.vm.vetf.setText("" + this.vm.ve);
			props.applyChanges();
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("/5"))
			{
			setCursor(Cursor.WAIT_CURSOR);
			this.vm.ve /= 5F;
			this.vm.vetf.setText("" + this.vm.ve);
			props.applyChanges();
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("/10"))
			{
			setCursor(Cursor.WAIT_CURSOR);
			this.vm.ve /= 10F;
			this.vm.vetf.setText("" + this.vm.ve);
			props.applyChanges();
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("Erase All Picks"))
			{
			/*picks.picktext.setText("");*/
			picks.eraseAll();
			this.vm.cvs.repaint();
			}
		else if (label.equals("Apply Geometry..."))
			{
			setCursor(Cursor.WAIT_CURSOR);
			sideComp(geom);
			geom.show();
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("Animation") && vm.cvs instanceof FltVolCanvas)
			{
			vm.cvs.paintsw = FltVolCanvas.ANIM;
			vm.cvs.repaint();
			}
		else if (label.equals("100%"))
			{
			vm.cvs.zoom(1F);
			vm.disableZoom(0);
			}
		else if (label.equals("10%"))
			{
			vm.cvs.zoom(0.1F);
			vm.disableZoom(2);
			}
		else if (label.equals("25%"))
			{
			vm.cvs.zoom(0.25F);
			vm.disableZoom(3);
			}
		else if (label.equals("50%"))
			{
			vm.cvs.zoom(0.5F);
			vm.disableZoom(4);
			}
		else if (label.equals("75%"))
			{
			vm.cvs.zoom(0.75F);
			vm.disableZoom(5);
			}
		else if (label.equals("150%"))
			{
			vm.cvs.zoom(1.5F);
			vm.disableZoom(6);
			}
		else if (label.equals("200%"))
			{
			vm.cvs.zoom(2F);
			vm.disableZoom(7);
			}
		else if (label.equals("500%"))
			{
			vm.cvs.zoom(5F);
			vm.disableZoom(8);
			}
		else if (label.equals("Pick Window..."))
			{
			setCursor(Cursor.WAIT_CURSOR);
			sideComp(picks);
			picks.show();
			setCursor(Cursor.DEFAULT_CURSOR);
			}
		else if (label.equals("Slope Window..."))
			System.out.println("Selected " + label + "; not yet implemented");
		else if (label.equals("About JRG..."))
			{
			ViewmatNotice vn = new ViewmatNotice(this,
			"About JRG and Viewmat for Java",
			RgCopyright.Statement);
			vn.show();
			}
		}

	public void disposePlot()
		{
		deletefromFrameList(this);
		props.dispose();
		picks.dispose();
		geom.dispose();
		vm.sclim = null;
		vm.cvs.img = null;
		if (vms != null)
			vms[0].cvs.img = null;
		dispose();
		}
	
	static String titleforfile(String title)
		{
		char c;
		int count;
		char fname[] = new char[title.length()];
		count = 0;
		for (int i=0; i<title.length(); i++)
			{
			c = title.charAt(i);
			if (c == ' ' || c == '+')
				continue;
			fname[count] = c;
			count++;
			}
		return new String(fname, 0, count);
		}
		
	/* Constructor */
	ViewmatFrame(String name, Viewmat vm)
		{
		super(name);
		Windows = null;
		this.vms = null;
		this.vm = vm;
		vm.f = this;
		this.vm.f = this;
		this.fd = new FileDialog(this);
		this.path = null;
		this.plane = 0;
		this.setMenuBar(vm.makeMenuBar(this));
		this.addtoFrameList();
		addWindowListener(new WindowAdapter()
			{
			public void windowClosing(WindowEvent e)
				{
				disposePlot();
				}	
			});
		}
	/* Constructor */
	ViewmatFrame(String name, Viewmat vms[])
		{
		super(name);
		Windows = null;
		this.vms = vms;
		this.vm = vms[0];
		this.vm.f = this;
		for (int i=0; i<vms.length; i++)
			{
			vms[i].f = this;
			this.vms[i].f = this;
			}
		this.fd = new FileDialog(this);
		this.path = null;
		this.plane = 0;
		this.setMenuBar(vm.makeMenuBar(this));
		this.addtoFrameList();
		addWindowListener(new WindowAdapter()
			{
			public void windowClosing(WindowEvent e)
				{
				disposePlot();
				}	
			});
		}
	void addtoFrameList()
		{
		if (framelist == null || Windows == null)
			{
			framelist = new Vector();
			makeWindowMenu();
			}
		framelist.addElement(this);
		redoWindowMenu();
		}
	void deletefromFrameList(ViewmatFrame f)
		{
		if (framelist == null || Windows == null)
			return;
		framelist.removeElement(f);
		redoWindowMenu();
		}
	void makeWindowMenu()
		{
		if (Windows == null)
			Windows = new Menu("Windows", false);
		if (framelist == null)
			framelist = new Vector();
		redoWindowMenu();
		}
	void redoWindowMenu()
		{
		ViewmatFrame tf=null;
		for (int i=0; i<framelist.size(); i++)
			{
			tf = (ViewmatFrame)(framelist.elementAt(i));
			tf.Windows.removeAll();
			for (int j=0; j<framelist.size(); j++)
				tf.Windows.add(((ViewmatFrame)(framelist.elementAt(j))).getTitle());
			tf.getMenuBar().add(tf.Windows);
			tf.Windows.addActionListener(tf);
			}
		}
		
	void handleWriteASCII()
		{
		fd.setMode(FileDialog.SAVE);
		if (vm.fvol == null)
			fd.setTitle("Write Plane to ASCII File...");
		else
			fd.setTitle("Write Volume to ASCII File...");
		fd.setFile(titleforfile(this.getTitle()) + ".asc");
		centerComp(fd);
		fd.show();
		if (fd.getFile() != null)
			{
			path = fd.getDirectory() + fd.getFile();
			FileOutputStream fos = null;
			BufferedOutputStream bos = null;
			try {fos = new FileOutputStream(path); }
			catch(IOException ioe)
				{
				Errout("Can't create ascii data file " + path
					+ "\nData Not Saved, due to: " + ioe.toString());
				return;
				}
			bos = new BufferedOutputStream(fos);
			if (vm.fvol == null)
				vm.fp.writeASCII(bos);
			else
				vm.fvol.writeASCII(bos);
			}
		}
			
	void handleWriteBinary(boolean appending)
		{
		ViewmatAction vad=null;
		if (appending)
			{
			fd.setMode(FileDialog.LOAD);
			if (vm.fvol == null)
				fd.setTitle("Append Plane to Binary File...");
			else
				fd.setTitle("Append Volume to Binary File...");
			fd.setFile("data.flt");
			centerComp(fd);
			fd.show();
			if (fd.getFile() != null)
				{
				path = fd.getDirectory() + fd.getFile();
				vad = new ViewmatAction(this);
				vad.makeWriteBinary(path, appending);
				vad.center();
				vad.show();
				if (vad.done == false)
					{
					vad.dispose();
					return;
					}
				if (vm.fvol == null)
					{
					vm.fp.geogr = vad.geogr;
					/* altered 4/10/06 JNL to workaround MacOS 10.4 bug
					   thanks to Leiph Preston!
					new Thread (new appendBinaryFileRun(vm.fp, 
						vad.readtype, vad.samptype, vad.oldrg, path)).start();
					*/
					(new appendBinaryFileRun(vm.fp, 
						vad.readtype, vad.samptype, vad.oldrg, path)).run();
					}
				else
					{
					vm.fvol.geogr = vad.geogr;
					/* altered 4/10/06 JNL to workaround MacOS 10.4 bug
					   thanks to Leiph Preston!
					new Thread (new appendBinaryFileRun(vm.fvol, 
						vad.readtype, vad.samptype, vad.oldrg, path)).start();
					*/
					(new appendBinaryFileRun(vm.fvol, 
						vad.readtype, vad.samptype, vad.oldrg, path)).run();
					}
				}
			else
				return;
			}
		else
			{
			fd.setMode(FileDialog.SAVE);
			if (vm.fvol == null)
				fd.setTitle("Write Plane to Binary File...");
			else
				fd.setTitle("Write Volume to Binary File...");
			fd.setFile(titleforfile(this.getTitle()) + ".flt");
			centerComp(fd);
			fd.show();
			if (fd.getFile() != null)
				{
				path = fd.getDirectory() + fd.getFile();
				vad = new ViewmatAction(this);
				vad.makeWriteBinary(path, appending);
				vad.center();
				vad.show();
				if (vad.done == false || vad.readtype == -1)
					{
					Errout("Write canceled: file " + path + " not written.");
					vad.dispose();
					return;
					}
				if (vm.fvol == null)
					{
					vm.fp.geogr = vad.geogr;
					/* altered 4/10/06 JNL to workaround MacOS 10.4 bug
					   thanks to Leiph Preston!
					new Thread (new createBinaryFileRun(vm.fp, 
						vad.readtype, vad.samptype, vad.oldrg, path)).start();
					*/
					(new createBinaryFileRun(vm.fp, 
						vad.readtype, vad.samptype, vad.oldrg, path)).run();
					}
				else
					{
					vm.fvol.geogr = vad.geogr;
					/* altered 4/10/06 JNL to workaround MacOS 10.4 bug
					   thanks to Leiph Preston!
					new Thread (new createBinaryFileRun(vm.fvol, 
						vad.readtype, vad.samptype, vad.oldrg, path)).start();
					*/
					(new createBinaryFileRun(vm.fvol, 
						vad.readtype, vad.samptype, vad.oldrg, path)).run();
					}
				}
			else
				return;
			}
		vad.dispose();
		}
	void handleOpenBinary()
		{
		fd.setMode(FileDialog.LOAD);
		fd.setTitle("Read Binary File...");
		fd.setFile("data.flt");
		centerComp(fd);
		fd.show();
		if (fd.getFile() == null)
			return;
		path = fd.getDirectory() + fd.getFile();
		ViewmatAction vad = new ViewmatAction(this);
		vad.makeReadBinary(path);
		vad.center();
		vad.show();
		if (vad.done == false)
			{
			vad.dispose();
			return;
			}
		if (vad.iv1*vad.iv2*vad.iv3 <= 0)
			{
			/*Errout("Cannot create a data buffer for file "
			+ path + "\nwith " + vad.iv3 + " planes of " + vad.iv2
			+ " vectors of " + vad.iv1 + " elements;\n"
			+ " all sizes must be positive integers.");*/
			vad.dispose();
			return;
			}
		if (vad.readtype == 1) /* SEG-Y */
			/* altered 3/1/06 JNL to workaround MacOS 10.4 bug thanks to Leiph Preston!
			new Thread (new readSEGYFileRun(fd.getDirectory(),
				path, vad.sfhd, vad.iv3, vad.samptype)).start();
			*/
			(new readSEGYFileRun(fd.getDirectory(),
				path, vad.sfhd, vad.iv3, vad.samptype)).run();
		else if (vad.readtype == 12 || vad.readtype == 13) /* SAC */
			(new readSACFileRun(fd.getDirectory(), path, vad.iv3,
				(vad.readtype==13 ? true : false))).run();
		else if (vad.iv3 > 1)
			/* altered 4/10/06 JNL to workaround MacOS 10.4 bug thanks to Leiph Preston!
			new Thread (new readBinaryFileRun(fd.getDirectory(),
				path, vad.readtype, vad.iv0, vad.iv3, vad.iv2, vad.iv1,
				vad.oldrg)).start();
			*/
			(new readBinaryFileRun(fd.getDirectory(),
				path, vad.readtype, vad.iv0, vad.iv3, vad.iv2, vad.iv1,
				vad.oldrg)).run();
		else
			{
			if (vm.fvol == null && vm.inplace.getState())
				{
				vm.fp = new FltPlane(vad.iv2, vad.iv1);
				/*
				if (vad.readtype == 1) * SEG-Y *
					vm.fp.readBinaryFile(path, vad.iv0);
				else*/ if (vad.readtype == 2) /* RG */
					vm.fp.readRGFile(path, vad.oldrg);
				else /* Raw */
					vm.fp.readBinaryFile(path, vad.iv0, vad.readtype);
				if (this.getTitle().equals("100x100 Zero Plane"))
					this.setTitle(path);
				else
					this.setTitle(this.getTitle() + " " + fd.getFile());
				props.setTitle(this.getTitle() + " Properties");
				this.vm.titletf.setText(this.getTitle());
				vm.cvs.vmat.clip = vm.fp.max();
				vm.cvs.vmat.title = new String(this.getTitle());
				vm.fp.replotinFrame(this);
				vm.cvs.zoom(vm.fzoom);
				vm.cvs.vmat.resetPropsPanel(props, props.pp);
				vm.cvs.vmat.setParameters(props, props.pp);
				}
			else
				{
				/* altered 4/10/06 JNL to workaround MacOS 10.4 bug thanks to Leiph Preston!
				new Thread (new readBinaryFileRun(fd.getDirectory(),
				path, vad.readtype,
				vad.iv0, vad.iv2, vad.iv1, vad.oldrg)).start();
				*/
				(new readBinaryFileRun(fd.getDirectory(),
				path, vad.readtype,
				vad.iv0, vad.iv2, vad.iv1, vad.oldrg)).run();
				/*this.dispose();*/
				}
			}
		vad.dispose();
		}
	
	void handleWriteSound()
		{
		String name = null;
		short samp;
		ViewmatAction vad=null;
		float hz;
		fd.setMode(FileDialog.SAVE);
		if (vm.fvol == null)
			{
			fd.setTitle("Write Plane to Sound File...");
			hz = 1F/vm.fp.getDUnitofDim(0);
			}
		else
			{
			fd.setTitle("Write Volume to Sound File...");
			hz = 1F/vm.fvol.getDUnitofDim(0);
			}
		fd.setFile(titleforfile(this.getTitle()) + ".aif");
		centerComp(fd);
		fd.show();
		if (fd.getFile() != null)
			{
			path = fd.getDirectory() + fd.getFile();
			vad = new ViewmatAction(this);
			vad.path = new String(path);
			name = new String(path);
			vad.beginPanel();
			vad.setTitle("Creating AIFF Sound File " + path + " ...");
			Label tlab1 = new Label("Apparent Samples per Second:");
			vad.pp.add(tlab1);
			TextField tf1 = new TextField("" + hz, 8);
			vad.pp.add(tf1);
			Label tlab2 = new Label("Multiply SPS rate to speed up;");
			vad.pp.add(tlab2);
			Label tlab3 = new Label("divide SPS rate to slow down.");
			vad.pp.add(tlab3);
			Button apply = new Button("Create Sound File");
			vad.pp.add(apply);
			apply.addActionListener(vad);
			vad.finishPanel();
			vad.height = 200;
			vad.setSize(300, vad.height);
			vad.center();
			vad.show();
			if (vad.done == false)
				{
				vad.dispose();
				return;
				}
			float htemp;
			try {htemp = Float.valueOf(tf1.getText()).floatValue(); }
			catch (NumberFormatException nfe)
				{htemp = hz; }
			if (htemp == 0F && hz > 0F)
				htemp = hz;
			else if (htemp == 0F && hz == 0F)
				htemp = 8000F;
			else if (htemp < 0F)
				htemp = -htemp;
			hz = htemp;
			FltPlane sfp = null;
			if (vm.fvol == null)
				sfp = vm.fp;
			else
				sfp = vm.fvol;
			int ne = sfp.ne;
			int nv = sfp.vecs;
			float max = sfp.max();
			int sampperchan;
			if (nv == 1)
				sampperchan = ne;
			else
				sampperchan = (nv/2)*ne;
			AifFileHead aifhead = new AifFileHead((int)(hz), sampperchan);
			int i, bytes;
			FileOutputStream fos = null;
			BufferedOutputStream bos = null;
			DataOutputStream dos = null;
			sfp.Notice("Writing " + (aifhead.AIFFILEHEADBYTES + 4*sampperchan)
				+ "-byte AIFF sound file at " + ((int)(hz)) + "-Hz sampling to "
				+ name + "... ");
			try {fos = new FileOutputStream(name); }
			catch(IOException ioe)
				{
				sfp.Errout("Can't create file " + name + ": " + ioe.toString());
				return;
				}
			bos = new BufferedOutputStream(fos, 4*ne);
			dos = new DataOutputStream(bos);
			try
				{
				aifhead.write(dos);
				}
			catch(IOException ioe)
				{
				sfp.Errout("Could not write "
				+ aifhead.AIFFILEHEADBYTES + " bytes to AIFF file "
				+ name);
				return;
				}
			try
				{
				if (nv == 1)
					{
					for (i=0; i<ne; i++)
						{
						samp = (short)(32000F*sfp.vec[i]/max);
						dos.writeShort(samp);
						dos.writeShort(samp);
						}
					}
				else
					{
					for (int k=0; k<(nv/2); k++)
					for (i=0; i<ne; i++)
						{
						samp = (short)(32000F*sfp.vec[2*k*ne+i]/max);
						dos.writeShort(samp);
						samp = (short)(32000F*sfp.vec[(2*k+1)*ne+i]/max);
						dos.writeShort(samp);
						}
					}
				}
			catch(IOException ioe)
				{
				sfp.Errout("Could not write "
				+ (4*sampperchan) + " bytes to AIFF file "
				+ name);
				return;
				}
			try
				{
				dos.flush();
				bos.flush();
				fos.close();
				}
			catch(IOException ioe)
				{
				sfp.Errout("Could not close AIFF file " + name + ": " + ioe.toString());
				return;
				}
			sfp.Noticeln("done.");
			vad.dispose();
			}
		else
			return;
		}

	public void Errout(String Error)
		{
		System.out.println();
		System.out.println(Error);
		System.out.println();
		System.out.flush();
		ViewmatNotice vn = new ViewmatNotice(this,
		"Error on " + this.getTitle(), Error);
		vn.show();
		}
	
	void adjustScreenLocation(Component c, Point p)
		{
		Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
		Dimension s = c.getSize();
		if ((p.x + s.width) > screen.width)
			p.x = screen.width - s.width;
		if ((p.y + s.height) > (screen.height - 28))
			p.y = screen.height - s.height - 28;
		if (p.x < 0)
			p.x = 0;
		if (p.y < 20)
			p.y = 20;
		c.setLocation(p);
		}
	void resetLocation()
		{
		adjustScreenLocation(this, this.getLocation());
		}
		
	void centerComp(Component c)
		{
		Point p = getLocation();
		Dimension d = getSize();
		Dimension s = c.getSize();
		p.translate((d.width - s.width)/2 + 40,
			(d.height - s.height)/2);
		adjustScreenLocation(c, p);
		}

	void sideComp(Component c)
		{
		int left, right;
		Point p = getLocation();
		Dimension d = getSize();
		Dimension s = c.getSize();
		Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
		left = p.x;
		right = screen.width - p.x - d.width;
		if (left > right)
			p.translate(-(s.width), 0);
		else
			p.translate(d.width, 0);
		adjustScreenLocation(c, p);
		}

	void setNextLocation()
		{
		Point p = new Point(nextx, nexty);
		p.translate(40, 40);
		adjustScreenLocation(this, p);
		nextx = p.x;
		nexty = p.y;
		}
	

	/* End of ViewmatFrame class */
	}

class createPSFileRun /* implements java.lang.Runnable  removed 4/10/06 to work around MacOS 10.4 bug */
	{
	Viewmat vm;
	String path;
	int plane;
	public void run()
		{
		if (plane > -1)
			vm.createPSFile(path, plane);
		else
			vm.createPSFile(path);
		}
	createPSFileRun(Viewmat vm, String path)
		{
		this.vm = vm;
		this.path = path;
		this.plane = -1;
		}
	createPSFileRun(Viewmat vm, String path, int plane)
		{
		this.vm = vm;
		this.path = path;
		this.plane = plane;
		}
	}

class createBinaryFileRun /* implements java.lang.Runnable  removed 4/10/06 to work around MacOS 10.4 bug */
	{
	FltPlane fp;
	String path;
	int readtype;
	int samptype;
	boolean oldrg;
	public void run()
		{
		fp.createBinaryFile(readtype, samptype, oldrg, path);
		}
	createBinaryFileRun(FltPlane fp, int readtype, int samptype, boolean oldrg,
		String path)
		{
		this.fp = fp;
		this.readtype = readtype;
		this.samptype = samptype;
		this.oldrg = oldrg;
		this.path = path;
		}
	}
class appendBinaryFileRun /* implements java.lang.Runnable  removed 4/10/06 to work around MacOS 10.4 bug */
	{
	FltPlane fp;
	String path;
	int readtype;
	int samptype;
	boolean oldrg;
	public void run()
		{
		fp.appendBinaryFile(readtype, samptype, oldrg, path);
		}
	appendBinaryFileRun(FltPlane fp, int readtype, int samptype, boolean oldrg,
		String path)
		{
		this.fp = fp;
		this.readtype = readtype;
		this.samptype = samptype;
		this.oldrg = oldrg;
		this.path = path;
		}
	}

class readBinaryFileRun /* implements java.lang.Runnable  removed 4/10/06 to work around MacOS 10.4 bug */
	{
	FltPlane fp;
	FltVol fvol;
	String path;
	String dir;
	int skip, filetype;
	boolean oldrg;
	public void run()
		{
		if (fvol == null)
			{
			if (filetype == 2) /* RG */
				fp.readRGFile(path, oldrg);
			else /* Raw */
				fp.readBinaryFile(path, skip, filetype);
			fp.viewinFrame(dir, path, false, 1F, RgCtab.vagray, false, -1F);
			}
		else
			{
			if (filetype == 2) /* RG */
				fvol.readRGFile(path, oldrg);
			else /* Raw */
				fvol.readBinaryFile(path, skip, filetype);
			fvol.viewinFrame(dir, path, false, 1F, RgCtab.vagray, false, -1F);
			}
		}
	readBinaryFileRun(String dir, String path, int filetype,
		int skip, int nv, int ne, boolean oldrg)
		{
		this.dir = new String(dir);
		this.path = new String(path);
		this.filetype = filetype;
		this.oldrg = oldrg;
		this.skip = skip;
		this.fp = new FltPlane(nv, ne);
		this.fvol = null;
		}
	readBinaryFileRun(String dir, String path, int filetype,
		int skip, int np, int nv, int ne, boolean oldrg)
		{
		this.dir = new String(dir);
		this.path = new String(path);
		this.filetype = filetype;
		this.oldrg = oldrg;
		this.skip = skip;
		this.fp = null;
		this.fvol = new FltVol(np, nv, ne);
		}
	}

class readSEGYFileRun
/*implements java.lang.Runnable removed 3/1/06 to work around MacOS 10.4 bug */
	{
	FltPlane fp;
	FltVol fvol;
	String path;
	String dir;
	SEGYFileHead sfhd;
	RgHead rghd[];
	long addresses[];
	RgFileHead fhd;
	int np, nv, ne, samptype;
	public void run()
		{
		if (np > 1)
			{
			this.fp = null;
			this.fvol = new FltVol(np, nv, ne);
			this.fvol.headers = rghd;
			this.fvol.geogr = sfhd.geogr;
			}
		else
			{
			this.fp = new FltPlane(nv, ne);
			this.fp.headers = rghd;
			this.fp.geogr = sfhd.geogr;
			this.fvol = null;
			}
		if (fvol == null)
			{
			fp.setUnit0ofDim(0, fhd.starttime);
			fp.setDUnitofDim(0, fhd.dt);
			fp.setUnitsofDim(0, "Time, sec");
			fp.setUnit0ofDim(1, 0);
			fp.setUnitsofDim(1, "Trace Sequence");
			fp.setDUnitofDim(1, 1);
			fp.readSEGYFile(path, addresses, samptype);
			fp.viewinFrame(dir, path, true, 0.04F, RgCtab.vagray, false, fp.rms());
			}
		else
			{
			fvol.setUnit0ofDim(0, fhd.starttime);
			fvol.setDUnitofDim(0, fhd.dt);
			fvol.setUnitsofDim(0, "Time, sec");
			fvol.setUnit0ofDim(1, 0);
			fvol.setUnitsofDim(1, "Trace Sequence");
			fvol.setDUnitofDim(1, 1);
			fvol.setUnit0ofDim(2, 0);
			fvol.setUnitsofDim(2, "Record Index");
			fvol.setDUnitofDim(2, 1);
			fvol.readSEGYFile(path, addresses, samptype);
			fvol.viewinFrame(dir, path, true, 0.04F, RgCtab.vagray, false, fvol.rms());
			}
		}
	/* Constructor */
	readSEGYFileRun(String dir, String path, SEGYFileHead sfhd,
		int np, int samptype)
		{
		this.dir = new String(dir);
		this.path = new String(path);
		this.np = np;
		this.samptype = samptype;
		this.nv = sfhd.ntrace;
		this.ne = sfhd.getnt();
		this.sfhd = sfhd;
		this.addresses = new long[sfhd.addresses.size()];
		Long temp;
		for (int i=0; i<addresses.length; i++)
			{
			temp = (Long)(sfhd.addresses.elementAt(i));
			this.addresses[i] = temp.longValue();
			}
		this.rghd = new RgHead[sfhd.headers.size()];
		for (int i=0; i<this.rghd.length; i++)
			this.rghd[i] = new RgHead((RgHead)(sfhd.headers.elementAt(i)));
		fhd = new RgFileHead(sfhd.fhd);
		}

	}

class readSACFileRun /*implements java.lang.Runnable removed 3/1/06 to work around MacOS 10.4 bug */
	{
	FltPlane fp;
	FltVol fvol;
	String path;
	String dir;
	RgFileHead fhd;
	int np, nv, ne;
	boolean isIntel;
	float dt;
	public void run()
		{
		if (fhd == null || nv < 1)
			return;
		if (np > 1)
			{
			this.fp = null;
			this.fvol = new FltVol(np, nv, ne);
			}
		else
			{
			this.fp = new FltPlane(nv, ne);
			this.fvol = null;
			}
		if (fvol == null)
			{
			SACTraceHead.readSACFiletoFP(fp, path, fhd, isIntel);
			fp.viewinFrame(dir, path, false, 100F, RgCtab.vagray, false, fp.max());
			}
		else
			{
			SACTraceHead.readSACFiletoFV(fvol, path, fhd, np, isIntel);
			fvol.viewinFrame(dir, path, false, 100F, RgCtab.vagray, false, fvol.max());
			}
		}
	/* Constructor */
	readSACFileRun(String dir, String path, int np, boolean isIntel)
		{
		this.dir = new String(dir);
		this.path = new String(path);
		this.np = np;
		this.isIntel = isIntel;
		this.fhd = SACTraceHead.scanSACFile(path, np, isIntel);
		if (fhd.ntrace < 1)
			{
			this.nv = 0;
			this.ne = 0;
			this.dt = 0F;
			fhd = null;
			}
		else
			{
			if (np > 1)
				this.nv = fhd.ntrace/np;
			else
				this.nv = fhd.ntrace;
			this.ne = fhd.nt;
			this.dt = fhd.dt;
			}
		}

	}