[RUFerret]

For the life of me.. I have no idea what to do beyond this. We only covered GUIs to an extent, so the error I'm receiving I do not know what it means, nor do I know what to do when it is explained in other topics.

Could somebody please explain and show me the right way?

Thank you.

import javax.swing.*;
import java.awt.event.*;
import java.util.*;
public class photo implements ActionListener
{
	public JButton bw;
	public JButton neg;
	public JButton sepia;
	public JButton original;
	public static void main(String[] args)
	{
		Scanner scan = new Scanner(System.in);
		Picture photo = new Picture();
		String file = "peter.jpg";
		photo.load(file);
		Pixel[] array = photo.getPixels();
		photo function = new photo();
		
		JFrame gui = new JFrame("Photo Manipulation");
		gui.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		JPanel buttons = new JPanel();
		buttons.setLayout(new GridLayout(2,2));
		JButton bw = new JButton();
		bw.setText("Black and White");
		buttons.add(bw);
		JButton neg = new JButton();
		neg.setText("Negative");
		buttons.add(neg);
		JButton sepia = new JButton();
		sepia.setText("Sepia");
		buttons.add(sepia);
		JButton original = new JButton();
		original.setText("Black and White");
		buttons.add(original);
		
		gui.getContentPane().add(buttons);
		gui.pack();
		gui.setVisible(true);
	}
	public void actionPerformed(ActionEvent event, Pixel[] array, Picture photo, String file, photo function)
	{
		if (event.getSource() == bw)
		{	
			function.bw(array,photo,file);
		}
		else if (event.getSource() == neg)
		{
			function.neg(array,photo,file);
		}
		else if (event.getSource() == sepia)
		{
			function.sepia(array,photo,file);
		}
		else if (event.getSource() == original)
		{
			photo.show();
		}
	}
	public void GUI(JButton a, JButton b, JButton c, JButton d)
	{
		bw = a;
		neg = b;
		sepia = c;
		original = d;
		bw.addActionListener(this);
		neg.addActionListener(this);
		sepia.addActionListener(this);
		original.addActionListener(this);
	}
	public void bw(Pixel[] array, Picture photo, String file)
	{
		Picture temp = new Picture();
		temp.load(file);
		Pixel[] temparray = temp.getPixels();
		for (int i = 0; i<array.length; i++)
		{
			int r = temparray[i].getRed();
			int g = temparray[i].getGreen();
			int b = temparray[i].getBlue();
			int w = (r+b+g)/3;
			temparray[i].setRed(w);
			temparray[i].setGreen(w);
			temparray[i].setBlue(w);
		}
		temp.show();
	}
	public void sepia(Pixel[] array, Picture photo, String file)
	{
		Picture temp = new Picture();
		temp.load(file);
		Pixel[] temparray = temp.getPixels();
		for (int i = 0; i<array.length; i++)
		{
			int r = temparray[i].getRed();
			int g = temparray[i].getGreen();
			int b = temparray[i].getBlue();		
			int w = (r+b+g)/3;
			temparray[i].setRed(w);
			temparray[i].setGreen(w);
			temparray[i].setBlue(w);
			r=w;
			g=w;
			b=w;
			if (r < 63)
			{ 
				r=(int)(r*1.1); 
				b=(int)(b*.9);
				temparray[i].setRed(r);
				temparray[i].setBlue(B)/>;
			} 
			if (r > 62 && r < 192)
			{
				r=(int)(r*1.15); 
				b=(int)(b*.85); 
				temparray[i].setRed(r);
				temparray[i].setBlue(B)/>;
				if (r  >191)
				{ 
					r=(int)(r*1.08); 
					temparray[i].setRed(r);
					if (r> 255)
					{ 
					r=255; 
					b=(int)(b*.93); 
					temparray[i].setRed(r);
					temparray[i].setBlue(B)/>;
					}
				}
			}
		}
		temp.show();
	}
	public void neg(Pixel[] array, Picture photo, String file)
	{
		Picture temp = new Picture();
		temp.load(file);
		Pixel[] temparray = temp.getPixels();
		for (int i = 0; i<array.length; i++)
		{
			int r = temparray[i].getRed();
			int g = temparray[i].getGreen();
			int b = temparray[i].getBlue();
			r=255-r;
			g=255-g;
			b=255-b;
			temparray[i].setRed(r);
			temparray[i].setGreen(g);
			temparray[i].setBlue(B)/>;
		}
		temp.show();
	}
	public void random(Pixel[] array, Picture photo, String file)
	{
		Random rand = new Random();
		Picture temp = new Picture();
		temp.load(file);
		Pixel[] temparray = temp.getPixels();
		for (int i = 0; i<array.length; i++)
		{
			temparray[i].setRed(rand.nextInt(255));
			temparray[i].setGreen(rand.nextInt(255));
			temparray[i].setBlue(rand.nextInt(255));
		}
	}
}

ERROR:

photo.java:4: photo is not abstract and does not override abstract method action
Performed(java.awt.event.ActionEvent) in java.awt.event.ActionListener
public class photo implements ActionListener
^
photo.java:23: cannot find symbol
symbol : class GridLayout

The last one I KNOW it's a small problem, since it's the right code (from my other GUI that works T_T)
location: class photo
buttons.setLayout(new GridLayout(2,2));

[mufasa]

the first error is occuring because you'e not quite correctly implementing the method "public void actionPerformed(ActionEvent e)" because you have too many parameters, the method as declared in the ActionListener interface only has the one parameter (ActionEvent e).

the second error is because you need to import the GridLayout class (as it's not currently imported, it can't be found)

[RUFerret]

Right. So that did not help me. (crap) I don't know what you're talking about. Please take note that I'm a collect student, and I just finished my first Java course. I don't know many terms, but I am decent at coding. I'm just trying to learn and perfect GUIs.

I know I don't need to import GridLayout, because I never had to in my other GUI (a calculator)



Gotcha. So I didn't import java.awt.*;

If that's what you meant, thanks! Now to just figure out the implementation error

This post has been edited by RUFerret: 17 December 2010 - 05:58 PM

[mufasa]

instead of :

 public void actionPerformed(ActionEvent event, Pixel[] array, Picture photo, String file, photo function)

it needs to be :

public void actionPerformed(ActionEvent event)

to access the variables outside you could make them instance variable of the class in order to reference them

[RUFerret]

Hmm, how would I do that? I tried putting it into public variables, but it says I cannot reference from a static context.

[mufasa]

the variables themselves must be static in that case as well, how is the code looking now?

[RUFerret]

mufasa, on 17 December 2010 - 05:14 PM, said:

the variables themselves must be static in that case as well, how is the code looking now?

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import java.util.*;
public class photo implements ActionListener
{
	public JButton bw;
	public JButton neg;
	public JButton sepia;
	public JButton original;
	public Picture photo = new Picture();
	public String file = "peter.jpg";
	public Pixel[] array = photo.getPixels();
	public photo function = new photo();
	public static void main(String[] args)
	{
		Scanner scan = new Scanner(System.in);
		photo.load(file);
		
		JFrame gui = new JFrame("Photo Manipulation");
		gui.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		JPanel buttons = new JPanel();
		buttons.setLayout(new GridLayout(2,2));
		JButton bw = new JButton();
		bw.setText("Black and White");
		buttons.add(bw);
		JButton neg = new JButton();
		neg.setText("Negative");
		buttons.add(neg);
		JButton sepia = new JButton();
		sepia.setText("Sepia");
		buttons.add(sepia);
		JButton original = new JButton();
		original.setText("Original");
		buttons.add(original);
		
		gui.getContentPane().add(buttons);
		gui.pack();
		gui.setVisible(true);
	}
	public void actionPerformed(ActionEvent event)
	{
		if (event.getSource() == bw)
		{	
			function.bw(array,photo,file);
		}
		else if (event.getSource() == neg)
		{
			function.neg(array,photo,file);
		}
		else if (event.getSource() == sepia)
		{
			function.sepia(array,photo,file);
		}
		else if (event.getSource() == original)
		{
			photo.show();
		}
	}
	public void GUI(JButton a, JButton b, JButton c, JButton d)
	{
		bw = a;
		neg = b;
		sepia = c;
		original = d;
		bw.addActionListener(this);
		neg.addActionListener(this);
		sepia.addActionListener(this);
		original.addActionListener(this);
	}
	public void bw(Pixel[] array, Picture photo, String file)
	{
		Picture temp = new Picture();
		temp.load(file);
		Pixel[] temparray = temp.getPixels();
		for (int i = 0; i<array.length; i++)
		{
			int r = temparray[i].getRed();
			int g = temparray[i].getGreen();
			int b = temparray[i].getBlue();
			int w = (r+b+g)/3;
			temparray[i].setRed(w);
			temparray[i].setGreen(w);
			temparray[i].setBlue(w);
		}
		temp.show();
	}
	public void sepia(Pixel[] array, Picture photo, String file)
	{
		Picture temp = new Picture();
		temp.load(file);
		Pixel[] temparray = temp.getPixels();
		for (int i = 0; i<array.length; i++)
		{
			int r = temparray[i].getRed();
			int g = temparray[i].getGreen();
			int b = temparray[i].getBlue();		
			int w = (r+b+g)/3;
			temparray[i].setRed(w);
			temparray[i].setGreen(w);
			temparray[i].setBlue(w);
			r=w;
			g=w;
			b=w;
			if (r < 63)
			{ 
				r=(int)(r*1.1); 
				b=(int)(b*.9);
				temparray[i].setRed(r);
				temparray[i].setBlue(B)/>;
			} 
			if (r > 62 && r < 192)
			{
				r=(int)(r*1.15); 
				b=(int)(b*.85); 
				temparray[i].setRed(r);
				temparray[i].setBlue(B)/>;
				if (r  >191)
				{ 
					r=(int)(r*1.08); 
					temparray[i].setRed(r);
					if (r> 255)
					{ 
					r=255; 
					b=(int)(b*.93); 
					temparray[i].setRed(r);
					temparray[i].setBlue(B)/>;
					}
				}
			}
		}
		temp.show();
	}
	public void neg(Pixel[] array, Picture photo, String file)
	{
		Picture temp = new Picture();
		temp.load(file);
		Pixel[] temparray = temp.getPixels();
		for (int i = 0; i<array.length; i++)
		{
			int r = temparray[i].getRed();
			int g = temparray[i].getGreen();
			int b = temparray[i].getBlue();
			r=255-r;
			g=255-g;
			b=255-b;
			temparray[i].setRed(r);
			temparray[i].setGreen(g);
			temparray[i].setBlue(B)/>;
		}
		temp.show();
	}
	public void random(Pixel[] array, Picture photo, String file)
	{
		Random rand = new Random();
		Picture temp = new Picture();
		temp.load(file);
		Pixel[] temparray = temp.getPixels();
		for (int i = 0; i<array.length; i++)
		{
			temparray[i].setRed(rand.nextInt(255));
			temparray[i].setGreen(rand.nextInt(255));
			temparray[i].setBlue(rand.nextInt(255));
		}
	}
}

Basically, I want this:

Click 1 of 4 buttons. on click, that button executes a function call, which manipulates the string (file) pixel by pixel.

Here's what I'm converting it from.

import java.util.*;
public class photo
{
	public static void main(String[] args)
	{
		Scanner scan = new Scanner(System.in);
		String file = "ta.jpg";
		Picture photo = new Picture();
		photo.load(file);
		Pixel[] array = photo.getPixels();
		photo function = new photo();
		
		System.out.println("Enter effect>");
		String command = scan.nextLine();
		while(!command.equals("quit"))
		{
			if (command.equals("blackAndWhite"))
			{
				function.bw(array,photo);
			}
			else if (command.equals("sepia"))
			{
				function.sepia(array,photo);
			}
			else if (command.equals("negative"))
			{
				function.neg(array,photo);
			}
			else if (command.equals("help"))
			{
				System.out.println("Effects are:");
				System.out.println("blackAndWhite");
				System.out.println("sepia");
				System.out.println("negative");
			}
			System.out.println("Enter effect>");
			command = scan.nextLine();
		}
	}
	public void bw(Pixel[] array, Picture photo)
	{
		for (int i = 0; i<array.length; i++)
		{
			int r = array[i].getRed();
			int g = array[i].getGreen();
			int b = array[i].getBlue();
			int w = (r+g+B)/>/3;
			array[i].setRed(w);
			array[i].setGreen(w);
			array[i].setBlue(w);
		}
		photo.show();
	}
	public void sepia(Pixel[] array, Picture photo)
	{
		for (int i = 0; i<array.length; i++)
		{
			int r = array[i].getRed();
			int g = array[i].getGreen();
			int b = array[i].getBlue();
			int w = (r+g+B)/>/3;
			array[i].setRed(w);
			array[i].setGreen(w);
			array[i].setBlue(w);
			r=w;
			g=w;
			b=w;
			if(r<63)
			{
				r=(int)(r*1.1);
				b=(int)(b*.9);
				array[i].setRed(r);
				array[i].setBlue(B)/>;
			}
			else if (r > 62 && r < 192)
			{
				r=(int)(r*1.15);
				b=(int)(b*.85);
				array[i].setRed(r);
				array[i].setBlue(B)/>;
			}
			else if (r > 191)
			{
				r=(int)(r*1.08);
				array[i].setRed(r);
				if (r > 255)
				{
					r=255;
					b=(int)(b*.93);
					array[i].setRed(r);
					array[i].setBlue(B)/>;
				}
			}
		}
		photo.show();
	}
	public void neg(Pixel[] array, Picture photo)
	{
		for (int i = 0; i<array.length; i++)
		{
			int r = array[i].getRed();
			int g = array[i].getGreen();
			int b = array[i].getBlue();
			r=255-r;
			g=255-g;
			b=255-b;
			array[i].setRed(r);
			array[i].setGreen(g);
			array[i].setBlue(B)/>;			
		}
		photo.show();
	}
}

It's just a command loop

[mufasa]

firstly, it would be better practice to break up the code (i.e. have the action listener separate from the class manipulating the picture.

second, can we see the Picture class? i'd just like to compile and run the program to see what errors you're getting. as it is now though there are a couple of compile errors, like the difference between the lower case 'b' in line 98 and the capital 'B' in line 111.

what errors are you getting now?

EDIT: looking back over your code, it would be better to add individually specific listeners to each button, i.e. for the sepia button in line 69

sepia.addActionListener (new ActionListener() {
     public void actionPerformed(ActionEvent e){
        Picture temp = new Picture();
        temp.load(file);
        Pixel[] temparray = temp.getPixels();
        for (int i = 0; i<array.length; i++)
        {
            int r = temparray[i].getRed();
            int g = temparray[i].getGreen();
            int b = temparray[i].getBlue();
            r=255-r;
            g=255-g;
            b=255-b;
            temparray[i].setRed(r);
            temparray[i].setGreen(g);
            temparray[i].setBlue(B)/>;
        }
        temp.show();
     }

});

instead of having a generic action listener which every button has and trying to figure out which button called the action listener in order to call a specific function (either inline the function in the specific action listeners actionPerformed() method or call it from there).

This post has been edited by mufasa: 17 December 2010 - 07:44 PM

[RUFerret]

Here is the Picture class.

Spoiler

import java.awt.*;
import java.awt.font.*;
import java.awt.geom.*;
import java.awt.image.BufferedImage;
import java.text.*;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import javax.swing.ImageIcon;
import java.awt.*;
import java.io.*;
import java.awt.geom.*;



import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.awt.image.*;
import javax.swing.border.*;


import javax.swing.*;
import java.awt.*;
import java.awt.image.*;



import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.Vector;
import javax.sound.sampled.*;
import java.lang.Math;
import java.awt.geom.*;



import javax.sound.sampled.*;
import java.io.*;
import java.util.Vector;



import javax.sound.sampled.*;
import java.io.*;


import javax.swing.*;
import javax.swing.SwingUtilities;
import java.text.*;


import javax.swing.JFileChooser;
import javax.swing.SwingUtilities;
import javax.swing.JFrame;

import java.io.*;
import java.net.*;


import java.awt.Image;
import java.awt.image.BufferedImage;

/**
 * A class to make working with a file chooser easier
 * for students.  It uses a JFileChooser to let the user
 * pick a file and returns the chosen file name.
 * <br>
 * Copyright Georgia Institute of Technology 2004
 * @author Barb Ericson ericson@cc.gatech.edu
 *
 * rewritten 05/08/09 by Dorn to make it thread safe and
 * to clean up code by refactoring
 */
class FileChooser
{

  ///////////////////////////// class fields ///////////////////

  private static String latestPath = null;

  /////////////////////// methods /////////////////////////////

  /**
   * Method to pick an item using the file chooser.
   * NOTE: This method is written to be threadsafe in the event
   * it is called from a thread other than the GUI event-dispatch thread.
   * @param fileChooser the file Chooser to use
   * @return the path name
   */
  private static String pickPath(final int selectionMode, final String caption)
  {
	//Create a place to store the return value from the JFileChooser in the other thread
	final String[] path = new String[1];

	Runnable pickAFileRunner =
		new Runnable() {
			public void run() {
				JFileChooser fileChooser = new JFileChooser();
				fileChooser.setDialogTitle(caption);
				fileChooser.setFileSelectionMode(selectionMode);

				/* create a JFrame to be the parent of the file
			         * chooser open dialog if you don't do this then
				 * you may not see the dialog.
    				 */
				JFrame frame = new JFrame();
				frame.setAlwaysOnTop(true);
				frame.getContentPane().add(fileChooser);

				String startPath;

				// Decide which path to start from, either latest path or the media dir
				if ( latestPath != null )
					startPath = latestPath;
				else
					startPath = getMediaDirectory();

				// Check to make sure path exists, if it doesn't, use home directory
				File testFile = new File(startPath);
				if (testFile.exists())
					fileChooser.setCurrentDirectory( testFile );
				else
					fileChooser.setCurrentDirectory( new File(System.getProperty("user.home")) );

				// get the return value from choosing a file
				int dialogReturn = fileChooser.showOpenDialog(frame);

				// if the return value says the user picked a file, save path and update latest path
				if (dialogReturn == JFileChooser.APPROVE_OPTION)
				{
					path[0] = fileChooser.getSelectedFile().getPath();
					latestPath = path[0];
				}
				else
				{
					path[0] = null;
				}
			}
		};

	try
	{
		// Run the code now to get the dialog on the GUI thread and then wait for a response
		if (SwingUtilities.isEventDispatchThread())
		{
			pickAFileRunner.run();
		}
		else
		{
			SwingUtilities.invokeAndWait(pickAFileRunner);
		}
		return path[0];
	}
	catch(Exception e)
	{
		return null;
	}
  }

  /**
   * Method to let the user pick a file and return
   * the full file name as a string.  If the user didn't
   * pick a file then the file name will be null.
   * @return the full file name of the picked file or null
   */
  public static String pickAFile()
  {
  	return pickPath(JFileChooser.FILES_ONLY, "Pick A File");
  }

  /**
   * Method to let the user pick a directory and return
   * the full path name as a string.
   * @return the full directory path
   */
  public static String pickADirectory()
  {
  	return pickPath(JFileChooser.DIRECTORIES_ONLY, "Pick A Folder");
  }

 /**
  * Method to get the full path for the passed file name
  * @param fileName the name of a file
  * @return the full path for the file
  */
 public static String getMediaPath(String fileName)
 {
	return getMediaDirectory() + fileName;
 }

 /**
  * Method to get the directory for the media
  * @return the media directory
  */
 private static String getMediaDirectory()
 {
	return "./";//JESConfig.getInstance().getStringProperty(JESConfig.CONFIG_MEDIAPATH);
 }


 /**
  * Method to set the media path by setting the directory to use
  * @param directory the directory to use for the media path
  */
 public static void setMediaPath(String directory)
 {
   // check if the directory exists
   File file = null;

   if ( directory != null )
     file = new File( directory );

   if ( ( file == null ) || ( !file.exists() ) )
   {
     System.out.println("Sorry but " + directory + " doesn't exist, try a different directory.");
   }
   else
   {
	if ( !directory.endsWith( File.separator ) )
		directory += File.separator;
     	//JESConfig.getInstance().setStringProperty(JESConfig.CONFIG_MEDIAPATH, directory);
   }
 }

 /**
  * Method to pick a media path using
  * the file chooser and set it
  */
 public static void pickMediaPath()
 {
 	setMediaPath( pickPath(JFileChooser.DIRECTORIES_ONLY, "Choose Media Path") );
 }

}
/**
 * Class that represents a sample of a sound.  It knows what sound object
 * it comes from and knows what frame number this sample is in the sound
 * object.
 * <br>
 * Copyright Georgia Institute of Technology 2004
 * @author Barb Ericson ericson@cc.gatech.edu
 */
class SoundSample
{
  /** the sound that this element belongs to */
  private SimpleSound sound = null;

  /** the frame number of this sample in the buffer */
  private int frameNumber = 0;

  ///////////////////// Constructors //////////////////////////////////

  /**
   * Constructor that takes a sound and valueArray
   * @param sound the sound object this sample comes from
   * @param frameNumber the frameNumber of this sample in the sound
   */
  public SoundSample(SimpleSound sound, int frameNumber)
  {
    this.sound = sound;
    this.frameNumber = frameNumber;
  }

  /////////////////// Methods /////////////////////////////////////////

  /**
   * Method to get the value of this sample as in int
   * and handle the possible sound exception
   * @return the value of this sample as an int
   */
  public int getValue() {
    int value = 0;
    try {
      value = sound.getSampleValue(frameNumber);
    } catch (SoundException ex) {
    }
    return value;
  }

  /**
   * Method to set the value of this sample and
   * handle the sound exception
   * @param value the value to use
   */
  public void setValue(int value)
  {
    try {
      sound.setSampleValue(frameNumber,value);
    } catch (SoundException ex) {
    }
  }

  /**
   * Method to return a string with the information about
   * this object
   * @return a string with information about this object
   */
  public String toString()
  {
    return "Sample at index " + frameNumber + " has value " + getValue();
  }
} // end of SoundSample class
/**
 * Class to make it easy to do output to the user
 * using JOptionPane
 * <br>
 * Copyright Georgia Institute of Technology 2004
 * @author Barb Ericson ericson@cc.gatech.edu
 *
 * 14 May 2009:  Edited by Dorn to ensure all JOptionPane calls to show are threadsafe.
 */
class SimpleOutput
{

  /**
   * Method to show a warning to a user
   * @param message the message to display
   */
  public static void showWarning(String message)
  {
    message = addNewLines(message);
    safeOutputDialog(message, "Warning Display", JOptionPane.WARNING_MESSAGE);
  }

  /**
   * Method to show an error to a user
   * @param message the message to display
   */
  public static void showError(String message)
  {
    message = addNewLines(message);
    safeOutputDialog(message, "Error Display", JOptionPane.ERROR_MESSAGE);
  }

  /**
   * Method to show information to the user
   * @param message the message to display
   */
  public static void showInformation(String message)
  {
    message = addNewLines(message);
    safeOutputDialog(message, "Information Display", JOptionPane.INFORMATION_MESSAGE);
  }

  /**
   * Method to add new line character if the message
   * is too long
   * @param message the input message
   * @return the message with new lines added if needed
   */
  public static String addNewLines(String message)
  {
    BreakIterator boundary =
      BreakIterator.getLineInstance();
    boundary.setText(message);
    int start = boundary.first();
    String result = "";
    String currLine = "";
    String temp = null;

    // loop till no more possible line breaks
    for (int end = boundary.next();
          end != BreakIterator.DONE;
          start = end, end = boundary.next())
    {
      // get string between start and end
      temp = message.substring(start,end);

      /* if adding that to the current line
       * would make it too long then add current
       * to result followed by a newline and
       * reset current
       */
      if (temp.length() + currLine.length() > 100)
      {
        result = result + currLine + "\n";
        currLine = temp;
      }
      // else add the segment to the current line
      else
        currLine = currLine + temp;
    }

    // if no line breaks use the original message
    if (result.length() == 0)
      result = message;
    // else add any leftover parts
    else
      result = result + currLine;

    return result;
  }

  private static void safeOutputDialog(final String message, final String title, final int messageType)
  {

	Runnable promptStringRunner =
		new Runnable() {
			public void run() {
				JOptionPane.showMessageDialog(null, message, title, messageType);
			}
		};

	try
	{
		if (SwingUtilities.isEventDispatchThread())
			promptStringRunner.run();
		else
			SwingUtilities.invokeAndWait(promptStringRunner);
	}
	catch(Exception e)
	{
		//do nothing
	}

  }

} // end of SimpleOutput class

/**
 * The class <code>Playback</code> extends from <code>Thread</code>
 * and allows for playback of a simple sound.  The thread doesn't die until
 * the sound is finished playing, however it is not blocking either.  It
 * will simply play the sound in the "background."
 * <br>
 * Copyright Georgia Institute of Technology 2004
 * @author unknown undergrad
 * @author Barb Ericson ericson@cc.gatech.edu
 */

  /*
   * conversion tools from tritonus (http://www.tritonus.org)
   */
  
  /*
   *      TConversionTool.java
   */ 
  
  /*
   *  Copyright (c) 1999,2000 by Florian Bomers <florian@bome.com>
   *  Copyright (c) 2000 by Matthias Pfisterer <matthias.pfisterer@gmx.de>
   *
   *
   *   This program is free software; you can redistribute it and/or modify
   *   it under the terms of the GNU Library General Public License as 
   *   published by the Free Software Foundation; either version 2 of the 
   *   License, or (at your option) any later version.
   *
   *   This program 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 Library General Public License for more details.
   *
   *   You should have received a copy of the GNU Library General Public
   *   License along with this program; if not, write to the Free Software
   *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   *
   */
class TConversionTool 
{
  
  /**
   * Converts 2 successive bytes starting at <code>byteOffset</code> in 
   * <code>buffer</code> to a signed integer sample with 16bit range.
   * <p>
   * For little endian, buffer[byteOffset] is interpreted as low byte,
   * whereas it is interpreted as high byte in big endian.
   * <p> This is a reference function.
   */ 
  public static int bytesToInt16( byte [] buffer, int byteOffset, 
                                  boolean bigEndian) 
  { 
    return bigEndian?
      ((buffer[byteOffset]<<8) | (buffer[byteOffset+1] & 0xFF)):
      
      ((buffer[byteOffset+1]<<8) | (buffer[byteOffset] & 0xFF));
  } 
  
  /**
   * Converts 3 successive bytes starting at <code>byteOffset</code> in 
   * <code>buffer</code> to a signed integer sample with 24bit range.
   * <p>
   * For little endian, buffer[byteOffset] is interpreted as lowest byte,
   * whereas it is interpreted as highest byte in big endian.
   * <p> This is a reference function.
   */ 
  public static int bytesToInt24( byte [] buffer, int byteOffset, 
                                  boolean bigEndian) 
  { 
    return bigEndian?
      ((buffer[byteOffset]<<16) // let Java handle sign-bit 
         | ((buffer[byteOffset+1] & 0xFF)<<8) // inhibit sign-bit handling 
         | ((buffer[byteOffset+2] & 0xFF))):
      
      ((buffer[byteOffset+2]<<16) // let Java handle sign-bit 
         | ((buffer[byteOffset+1] & 0xFF)<<8) // inhibit sign-bit handling 
         | (buffer[byteOffset] & 0xFF));
  } 
  
  /**
   * Converts a 4 successive bytes starting at <code>byteOffset</code> in 
   * <code>buffer</code> to a signed 32bit integer sample.
   * <p>
   * For little endian, buffer[byteOffset] is interpreted as lowest byte,
   * whereas it is interpreted as highest byte in big endian.
   * <p> This is a reference function.
   */ 
  public static int bytesToInt32( byte [] buffer, int byteOffset, 
                                  boolean bigEndian) 
  { 
    return bigEndian?
      ((buffer[byteOffset]<<24) // let Java handle sign-bit 
         | ((buffer[byteOffset+1] & 0xFF)<<16) // inhibit sign-bit handling 
         | ((buffer[byteOffset+2] & 0xFF)<<8) // inhibit sign-bit handling 
         | (buffer[byteOffset+3] & 0xFF)):
      
      ((buffer[byteOffset+3]<<24) // let Java handle sign-bit 
         | ((buffer[byteOffset+2] & 0xFF)<<16) // inhibit sign-bit handling 
         | ((buffer[byteOffset+1] & 0xFF)<<8) // inhibit sign-bit handling 
         | (buffer[byteOffset] & 0xFF));
  } 
  
  /////////////////////// ULAW ///////////////////////////////////////////
  
  private static final boolean ZEROTRAP=true;
  private static final short BIAS=0x84;
  private static final int CLIP=32635;
  private static final int exp_lut1[] ={
    0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,
    4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
    5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
    5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
    6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
    6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
    6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
    6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
  };
  
  
  /* u-law to linear conversion table */ 
  private static short [] u2l = {
    -32124, -31100, -30076, -29052, -28028, -27004, -25980, -24956,
    -23932, -22908, -21884, -20860, -19836, -18812, -17788, -16764,
    -15996, -15484, -14972, -14460, -13948, -13436, -12924, -12412,
    -11900, -11388, -10876, -10364, -9852, -9340, -8828, -8316,
    -7932, -7676, -7420, -7164, -6908, -6652, -6396, -6140,
    -5884, -5628, -5372, -5116, -4860, -4604, -4348, -4092,
    -3900, -3772, -3644, -3516, -3388, -3260, -3132, -3004,
    -2876, -2748, -2620, -2492, -2364, -2236, -2108, -1980,
    -1884, -1820, -1756, -1692, -1628, -1564, -1500, -1436,
    -1372, -1308, -1244, -1180, -1116, -1052, -988, -924,
    -876, -844, -812, -780, -748, -716, -684, -652,
    -620, -588, -556, -524, -492, -460, -428, -396,
    -372, -356, -340, -324, -308, -292, -276, -260,
    -244, -228, -212, -196, -180, -164, -148, -132,
    -120, -112, -104, -96, -88, -80, -72, -64,
    -56, -48, -40, -32, -24, -16, -8, 0,
    32124, 31100, 30076, 29052, 28028, 27004, 25980, 24956,
    23932, 22908, 21884, 20860, 19836, 18812, 17788, 16764,
    15996, 15484, 14972, 14460, 13948, 13436, 12924, 12412,
    11900, 11388, 10876, 10364, 9852, 9340, 8828, 8316,
    7932, 7676, 7420, 7164, 6908, 6652, 6396, 6140,
    5884, 5628, 5372, 5116, 4860, 4604, 4348, 4092,
    3900, 3772, 3644, 3516, 3388, 3260, 3132, 3004,
    2876, 2748, 2620, 2492, 2364, 2236, 2108, 1980,
    1884, 1820, 1756, 1692, 1628, 1564, 1500, 1436,
    1372, 1308, 1244, 1180, 1116, 1052, 988, 924,
    876, 844, 812, 780, 748, 716, 684, 652,
    620, 588, 556, 524, 492, 460, 428, 396,
    372, 356, 340, 324, 308, 292, 276, 260,
    244, 228, 212, 196, 180, 164, 148, 132,
    120, 112, 104, 96, 88, 80, 72, 64,
    56, 48, 40, 32, 24, 16, 8, 0
  }; 
  public static short ulaw2linear( byte ulawbyte) 
  { 
    return u2l[ulawbyte & 0xFF];
  } 
  
  /**
   * Converts a linear signed 16bit sample to a uLaw byte.
   * Ported to Java by fb.
   * <BR>Originally by:<BR>
   * Craig Reese: IDA/Supercomputing Research Center <BR>
   * Joe Campbell: Department of Defense <BR>
   * 29 September 1989 <BR>
   */
  public static byte linear2ulaw(int sample) {
    int sign, exponent, mantissa, ulawbyte;
    
    if (sample>32767) sample=32767;
    else if (sample<-32768) sample=-32768;
    /* Get the sample into sign-magnitude. */
    sign = (sample >> 8) & 0x80;    /* set aside the sign */
    if (sign != 0) sample = -sample;    /* get magnitude */
    if (sample > CLIP) sample = CLIP;    /* clip the magnitude */
    
    /* Convert from 16 bit linear to ulaw. */
    sample = sample + BIAS;
    exponent = exp_lut1[(sample >> 7) & 0xFF];
    mantissa = (sample >> (exponent + 3)) & 0x0F;
    ulawbyte = ~(sign | (exponent << 4) | mantissa);
    if (ZEROTRAP)
      if (ulawbyte == 0) ulawbyte = 0x02;  /* optional CCITT trap */
    return((byte) ulawbyte);
  }
  
  
  /*
   * This source code is a product of Sun Microsystems, Inc. and is provided
   * for unrestricted use.  Users may copy or modify this source code without
   * charge.
   *
   * linear2alaw() - Convert a 16-bit linear PCM value to 8-bit A-law
   *
   * linear2alaw() accepts an 16-bit integer and encodes it as A-law data.
   *
   *              Linear Input Code       Compressed Code
   *      ------------------------        ---------------
   *      0000000wxyza                    000wxyz
   *      0000001wxyza                    001wxyz
   *      000001wxyzab                    010wxyz
   *      00001wxyzabc                    011wxyz
   *      0001wxyzabcd                    100wxyz
   *      001wxyzabcde                    101wxyz
   *      01wxyzabcdef                    110wxyz
   *      1wxyzabcdefg                    111wxyz
   *
   * For further information see John C. Bellamy's Digital Telephony, 1982,
   * John Wiley & Sons, pps 98-111 and 472-476.
   */ 
  private static final byte QUANT_MASK = 0xf; /* Quantization field mask. */
  private static final byte SEG_SHIFT = 4;  /* Left shift for segment number. */
  private static final short[] seg_end = {
    0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF
  };
  
  
  /*
   * conversion table alaw to linear
   */
  private static short [] a2l = {
    -5504, -5248, -6016, -5760, -4480, -4224, -4992, -4736,
    -7552, -7296, -8064, -7808, -6528, -6272, -7040, -6784,
    -2752, -2624, -3008, -2880, -2240, -2112, -2496, -2368,
    -3776, -3648, -4032, -3904, -3264, -3136, -3520, -3392,
    -22016, -20992, -24064, -23040, -17920, -16896, -19968, -18944,
    -30208, -29184, -32256, -31232, -26112, -25088, -28160, -27136,
    -11008, -10496, -12032, -11520, -8960, -8448, -9984, -9472,
    -15104, -14592, -16128, -15616, -13056, -12544, -14080, -13568,
    -344, -328, -376, -360, -280, -264, -312, -296,
    -472, -456, -504, -488, -408, -392, -440, -424,
    -88, -72, -120, -104, -24, -8, -56, -40,
    -216, -200, -248, -232, -152, -136, -184, -168,
    -1376, -1312, -1504, -1440, -1120, -1056, -1248, -1184,
    -1888, -1824, -2016, -1952, -1632, -1568, -1760, -1696,
    -688, -656, -752, -720, -560, -528, -624, -592,
    -944, -912, -1008, -976, -816, -784, -880, -848,
    5504, 5248, 6016, 5760, 4480, 4224, 4992, 4736,
    7552, 7296, 8064, 7808, 6528, 6272, 7040, 6784,
    2752, 2624, 3008, 2880, 2240, 2112, 2496, 2368,
    3776, 3648, 4032, 3904, 3264, 3136, 3520, 3392,
    22016, 20992, 24064, 23040, 17920, 16896, 19968, 18944,
    30208, 29184, 32256, 31232, 26112, 25088, 28160, 27136,
    11008, 10496, 12032, 11520, 8960, 8448, 9984, 9472,
    15104, 14592, 16128, 15616, 13056, 12544, 14080, 13568,
    344, 328, 376, 360, 280, 264, 312, 296,
    472, 456, 504, 488, 408, 392, 440, 424,
    88, 72, 120, 104, 24, 8, 56, 40,
    216, 200, 248, 232, 152, 136, 184, 168,
    1376, 1312, 1504, 1440, 1120, 1056, 1248, 1184,
    1888, 1824, 2016, 1952, 1632, 1568, 1760, 1696,
    688, 656, 752, 720, 560, 528, 624, 592,
    944, 912, 1008, 976, 816, 784, 880, 848
  }; 
  
  public static short alaw2linear( byte ulawbyte) 
  { 
    return a2l[ulawbyte & 0xFF];
  } 
  
  public static byte linear2alaw(short pcm_val) 
    /* 2's complement (16-bit range) */
  {
    byte mask;
    byte seg=8;
    byte aval;
    
    if (pcm_val >= 0) {
      mask = (byte) 0xD5;  /* sign (7th) bit = 1 */
    } else {
      mask = 0x55;  /* sign bit = 0 */
      pcm_val = (short) (-pcm_val - 8);
    }
    
    /* Convert the scaled magnitude to segment number. */
    for (int i = 0; i < 8; i++) {
      if (pcm_val <= seg_end[i]) {
        seg=(byte) i;
        break;
      }
    }
    
    /* Combine the sign, segment, and quantization bits. */
    if (seg >= 8)  /* out of range, return maximum value. */
      return (byte) ((0x7F ^ mask) & 0xFF);
    else {
      aval = (byte) (seg << SEG_SHIFT);
      if (seg < 2)
        aval |= (pcm_val >> 4) & QUANT_MASK;
      else
        aval |= (pcm_val >> (seg + 3)) & QUANT_MASK;
      return (byte) ((aval ^ mask) & 0xFF);
    }
  }
  
  
  
  
  /**
   * Converts a 16 bit sample of type <code>int</code> to 2 bytes in an array.
   * <code>sample</code> is interpreted as signed (as Java does).
   * <p>
   * For little endian, buffer[byteOffset] is filled with low byte of sample, 
   * and buffer[byteOffset+1] is filled with high byte of sample + sign bit.
   * <p> For big endian, this is reversed.
   * <p> Before calling this function, it should be assured that 
   * <code>sample</code> is in the 16bit range - it will not be clipped.
   * <p> This is a reference function.
   */ 
  public static void intToBytes16( int sample, byte [] buffer, int byteOffset, 
                                   boolean bigEndian) 
  { 
    if (bigEndian) 
    {
      buffer[byteOffset++]=( byte ) (sample >> 8);
      buffer[byteOffset]=( byte ) (sample & 0xFF);
    } 
    else 
    {
      buffer[byteOffset++]=( byte ) (sample & 0xFF);
      buffer[byteOffset]=( byte ) (sample >> 8);
    }
  } 
  
  /**
   * Converts a 24 bit sample of type <code>int</code> to 3 bytes in an array.
   * <code>sample</code> is interpreted as signed (as Java does).
   * <p>
   * For little endian, buffer[byteOffset] is filled with low byte of sample, 
   * and buffer[byteOffset+2] is filled with the high byte of sample + 
   * sign bit.
   * <p> For big endian, this is reversed.
   * <p> Before calling this function, it should be assured that 
   * <code>sample</code> is in the 24bit range - it will not be clipped.
   * <p> This is a reference function.
   */ 
  public static void intToBytes24( int sample, byte [] buffer, 
                                   int byteOffset, boolean bigEndian) 
  { 
    if (bigEndian) 
    {
      buffer[byteOffset++]=( byte ) (sample >> 16);
      buffer[byteOffset++]=( byte ) ((sample >>> 8) & 0xFF);
      buffer[byteOffset]=( byte ) (sample & 0xFF);
    } 
    else 
    {
      buffer[byteOffset++]=( byte ) (sample & 0xFF);
      buffer[byteOffset++]=( byte ) ((sample >>> 8) & 0xFF);
      buffer[byteOffset]=( byte ) (sample >> 16);
    }
  } 
  
  /**
   * Converts a 32 bit sample of type <code>int</code> to 4 bytes in an array.
   * <code>sample</code> is interpreted as signed (as Java does).
   * <p>
   * For little endian, buffer[byteOffset] is filled with lowest byte of 
   * sample, and buffer[byteOffset+3] is filled with the high byte of 
   * sample + sign bit.
   * <p> For big endian, this is reversed.
   * <p> This is a reference function.
   */ 
  public static void intToBytes32( int sample, byte [] buffer, 
                                   int byteOffset, boolean bigEndian) 
  { 
    if (bigEndian) 
    {
      buffer[byteOffset++]=( byte ) (sample >> 24);
      buffer[byteOffset++]=( byte ) ((sample >>> 16) & 0xFF);
      buffer[byteOffset++]=( byte ) ((sample >>> 8) & 0xFF);
      buffer[byteOffset]=( byte ) (sample & 0xFF);
    } 
    else 
    {
      buffer[byteOffset++]=( byte ) (sample & 0xFF);
      buffer[byteOffset++]=( byte ) ((sample >>> 8) & 0xFF);
      buffer[byteOffset++]=( byte ) ((sample >>> 16) & 0xFF);
      buffer[byteOffset]=( byte ) (sample >> 24);
    }
  } 
  
  /*
   * Byte<->Int conversions for unsigned pcm data were written
   * by myself with help from Real's Java How-To:
   * http://www.rgagnon.com/javadetails/java-0026.html
   */
  
  public static int unsignedByteToInt(byte B)/> 
  {
    /* 
     * & 0xFF while seemingly doing nothing to the individual bits,
     * forces java to recognize the byte as unsigned.  so, we return to
     * the calling function a number between 0 and 256.
     */
    return ((int) b & 0xFF);
  }
  
  public static int unsignedByteToInt16(byte[] buffer, int offset, 
                                         boolean isBigEndian)
  {
    /*
     * here, we want to take the first byte and shift it left
     * 8 bits then concatenate on the 8 bits in the second byte.
     * now we have a 16 bit number that java will recognize as
     * unsigned, so we return a number in the range [0, 65536]
     */
    
    if(isBigEndian)
    {
      return ( (unsignedByteToInt(buffer[offset]) << 8) |
              unsignedByteToInt(buffer[offset+1]) );
    }
    else
    {
      return( (unsignedByteToInt(buffer[offset+1]) << 8) |
             unsignedByteToInt(buffer[offset]));
    }
    
  }
  
  public static int unsignedByteToInt24(byte[] buffer, int offset,
                                        boolean isBigEndian)
  {
    if(isBigEndian)
    {
      return ( (unsignedByteToInt(buffer[offset]) << 16) |
              (unsignedByteToInt(buffer[offset+1]) << 8) |
              unsignedByteToInt(buffer[offset+2]));
    }
    else
    {
      return ( (unsignedByteToInt(buffer[offset+2]) << 16) |
              (unsignedByteToInt(buffer[offset+1]) << 8) |
              unsignedByteToInt(buffer[offset]));
    }
  }
  
  public static int unsignedByteToInt32(byte[] buffer, int offset,
                                        boolean isBigEndian)
  {
    if(isBigEndian)
    {
      return( (unsignedByteToInt(buffer[offset]) << 24) |
             (unsignedByteToInt(buffer[offset+1]) << 16) |
             (unsignedByteToInt(buffer[offset+2]) << 8) |
             unsignedByteToInt(buffer[offset+3]) );
    }
    else
    {
      return((unsignedByteToInt(buffer[offset+3]) << 24) |
             (unsignedByteToInt(buffer[offset+2]) << 16) |
             (unsignedByteToInt(buffer[offset+1]) << 8) |
             unsignedByteToInt(buffer[offset]) );
    }
  }
  
  public static byte intToUnsignedByte(int sample)
  {
    /*
     * does the reverse of the function above
     * we have an integer that is signed, so we're in the range 
     * [-128, 127], we want to convert to an unsigned number in 
     * the range [0,256], then put that into an unsigned byte
     * all while java tries to treat everythign as signed.
     * 
     * so.... say we want to set the sample value to -128
     * in our unsigned byte, this translates to 0, so we want
     * java's representation of -128: 10000000 to instead be stored
     * as 0: 00000000 so, we simply xor with -128, flipping the sign bit
     *
     * another example we want to store the max value 127: 01111111
     * translating into the unsigned range, the max is 256: 11111111
     * again, you can see all we need to change is the sign bit.
     *
     * and lastly, for something in the middle:
     * say we want to store the value 0: 00000000
     * translating into the unsigned range, we have the middle
     * value 128: 10000000
     * again, we just want to flip the first bit
     *
     * something a little more tricky... say we want to store the value 32
     * now this translates to 32--128 = 160 in unsigned representation
     * so we start with 32 = 00100000 and we want to go to
     *                 160 = 10100000 
     *
     * see, we just flip the sign bit, its the same as adding 128 which
     * is how we translate between  [-128,127] and [0,256].
     */
    return((byte)(sample ^ -128));
  }
  
  
  
  public static void intToUnsignedBytes16(int sample, byte [] buffer, 
                                          int byteOffset, boolean bigEndian) 
  {
    
    /* 
     * for this comment only, treat ^ not as XOR as we use it in java
     * but as an exponent symbol like on a calculator, i thought 2^15 
     * would be clearer than 32768.
     * the theory here is very simmilar to the 8 bit conversion we
     * did above.  only now we have 16 bits we want to write into.
     * so, we're going from the range [-2^15, 2^15-1] into the range
     * [0, 2^16].  again, to translate, we just need to add 2^15 to
     * our number, so we get the first byte, by shifting right 8 bits, 
     * (note: >>> is unsigned shift), and then XOR with -128 to flip the
     * sign bit.  for the second byte, we just want the last 8 bits
     * of our integer, so we & with 0xff to tell java to treat this
     * as unsigned, and just copy over the bit values.
     */
    if(bigEndian)
    {
      buffer[byteOffset] = (byte)(sample >>> 8 ^ -128);
      buffer[byteOffset+1] = (byte)(sample & 0xff);
    }
    else
    {
      buffer[byteOffset+1] = (byte)(sample >>> 8 ^ -128);
      buffer[byteOffset] = (byte)(sample & 0xff);
    }
  }
  
  public static void intToUnsignedBytes24(int sample, byte [] buffer, 
                                          int byteOffset, boolean bigEndian)
  {
    if(bigEndian)
    {
      buffer[byteOffset] = (byte)(sample >>> 16 ^ -128);
      buffer[byteOffset+1] = (byte)(sample >>> 8);
      buffer[byteOffset +2] = (byte)(sample & 0xff);
    }
    else
    {
      buffer[byteOffset+2] = (byte)(sample >>> 16 ^ -128);
      buffer[byteOffset+1] = (byte)(sample >>> 8);
      buffer[byteOffset] = (byte)(sample & 0xff);
    }
  }
  
  public static void intToUnsignedBytes32(int sample, byte [] buffer, 
                                          int byteOffset, boolean bigEndian)
  {
    if(bigEndian)
    {
      buffer[byteOffset] = (byte)(sample >>> 24 ^ -128);
      buffer[byteOffset+1] = (byte)(sample >>> 16);
      buffer[byteOffset+2] = (byte)(sample >>> 8);
      buffer[byteOffset+3] = (byte)(sample & 0xff);
    }
    else
    {
      buffer[byteOffset+3] = (byte)(sample >>> 24 ^ -128);
      buffer[byteOffset+2] = (byte)(sample >>> 16);
      buffer[byteOffset+1] = (byte)(sample >>> 8);
      buffer[byteOffset] = (byte)(sample & 0xff);
    }
  }
}
class Playback extends Thread
{
  ///////////////// fields ////////////////////////////////////

  /**
   * Constant that is the default buffer size.
   * @see Sound#Sound()
   * @see Playback#run()
   */
  private static final int BUFFER_SIZE = 16384;

  /**
   * The source data line for the sound
   */
  private SourceDataLine line;

  /**
   * flag that says is the sound currently being played
   */
  private boolean playing = false;

  /**
   * The sound being played
   */
  private SimpleSound sound;

  ////////////////// Constructors //////////////////////////////////////

  /**
   * Constructor that takes the simple sound to be played
   * @param sound the simple sound to play
   */
  public Playback(SimpleSound sound)
  {
    this.sound = sound;
  }

  /**
   * Stop the playback
   */
  private void shutDown(String message, Exception e)
  {
    if (message != null)
    {
      System.err.println(message);
      e.printStackTrace();
    }
    playing = false;
  }

  /**
   * Stops this thread by breaking the while loop in the run method.
   * Used, for example, by the "stop" button in the SoundExplorer class.
   */
  public void stopPlaying()
  {
    playing = false;
  }

  /**
   * Method to return true if this playback thread is playing and
   * false otherwise
   * @return true if playing else false
   */
  public boolean getPlaying()
  {
    return playing;
  }

  /**
   * Starts this thread.  Gets an AudioInputStream, and writes is out
   * to a SourceDataLine.  If a SoundExplorer exists, upon creation of
   * the SourceDataLine, the soundExplorer is added as the LineListener.
   * When the thread finishes the run method, it removes itself from the
   * list of threads currently playing this sound.
   * @throws JavaSoundException if there were problems playing the sound.
   */
  public void run()
  {

    AudioFileFormat audioFileFormat = sound.getAudioFileFormat();
    SoundExplorer soundExplorer = sound.getSoundExplorer();

    //get something to play
    AudioInputStream audioInputStream = sound.makeAIS();
    if(audioInputStream == null)
    {
      shutDown("There is no input stream to play", null);
      return;
    }

    //reset stream to the begining
    try {
      audioInputStream.reset();
    } catch(Exception e) {
      shutDown("Problems resetting the stream\n", e);
      return;
    }

    /* define the required attributes for the line
     make sure a compatible line is supported */
    DataLine.Info info = new DataLine.Info(SourceDataLine.class,
                                           audioFileFormat.getFormat());
    if(!AudioSystem.isLineSupported(info))
    {
      shutDown("Line matching " + info + "not supported.", null);
      return;
    }

    //get and open the source data line for playback
    try {
      line = (SourceDataLine) AudioSystem.getLine(info);
      if(sound.getSoundExplorer() != null)
        line.addLineListener(soundExplorer);
      line.open(audioFileFormat.getFormat(), BUFFER_SIZE);
    } catch(LineUnavailableException e) {
      shutDown("Unable to open the line: ", e);
      return;
    }

    //play back the captured data
    int frameSizeInBytes = audioFileFormat.getFormat().getFrameSize();
    int bufferLengthInBytes = line.getBufferSize();
    int bufferLengthInFrames = bufferLengthInBytes / frameSizeInBytes;
    byte[] data = new byte[bufferLengthInBytes];
    int numBytesRead = 0;

    //start the source data line and begin playing
    line.start();
    playing = true;

    // the loop that actually writes the data out
    while(playing)
    {
      try {
        if((numBytesRead = audioInputStream.read(data))
             == -1)
        {
          break;//end of audioInputStream
        }
        int numBytesRemaining = numBytesRead;
        while(numBytesRemaining > 0)
        {
          numBytesRemaining -=
            line.write(data, 0, numBytesRemaining);
        }//while
      } catch(Exception e) {
        shutDown("Error during playback: ", e);
        break;
      }//catch
    }//while

    /* we reached the end of the stream or an error occurred.
     if we were playing, then let the data play out, else, skip to
     stopping and closing the line.
     */
    if(playing)
      line.drain();
    line.stop();
    line.close();
    line = null;
    shutDown(null, null);
    //if(sound.getDEBUG())
      //System.out.println("exiting run method");
    /*
     this thread is about to die.  remove itself from the collection
     of threads playing this sound
     */
    sound.removePlayback(this);

  }//run()

}//end class Playback

/**
 * Class to use to report a sound exception
 * <br>
 * Copyright Georgia Institute of Technology 2004
 * @author Unknown Undergraduate
 * @author Barb Ericson ericson@cc.gatech.edu
 */
class SoundException extends Exception
{

  private static final long serialVersionUID = 7526471155622776147L;

 /** Constructor that takes String as the message for the SoundException */
  public SoundException(String message)
  {
    super(message);
  }
} // end of SoundException class
/**
 * The <code>SimpleSound</code> class is an implementation of the
 * Java Sound API specifically designed for use with students.
 * <br>
 * http://java.sun.com/products/java-media/sound/index.html
 * <p>
 * This class allows for easy playback, and manipulation of AU,
 * AIFF, and WAV files.
 * <p>
 * Code & ideas for this class related to playing and
 * viewing the sound were borrowed from the Java Sound Demo:
 * http://java.sun.com/products/java-media/sound/
 * samples/JavaSoundDemo/
 * <br>
 * Also, some code borrowed from Tritonus as noted.
 * <br>
 * Copyright Georgia Institute of Technology 2004
 * @author Ellie Harmon, ellie@cc.gatech.edu
 * @author Barbara Ericson ericson@mindspring.com
 *
 * Changes merged by Buck Scharfnorth 22 May 2008
 * default numberOfChannels left to 1
 * stopPlaying() method added
 *
 * _SoundIndexOffset added (29 Oct 2008) -Buck
 */
class SimpleSound{

  ///////////////////////////// fields ////////////////////////

  /**
   * Constant for max negative value
   */
  public static final int MAX_NEG = -32768;

  /**
   * Constant for max positive value
   */
  public static final int MAX_POS = 32767;

  /**
   * Constant for the default sampling rate
   */
  public static final int SAMPLE_RATE = 22050;

  /**
   * Constant for the index base (0 or 1)
   */
  public static final int _SoundIndexOffset = 0;

  /**
   * Constant for the default sample size in bits
   * it is usual to have either 8 or 16
   */
  private static final int NUM_BITS_PER_SAMPLE = 16;

  /**
   * Flag to tell if in debug mode or not
   */
  private static final boolean DEBUG = false;

  /**
   * An array of bytes representing the sound.
   */
  private byte[] buffer;

  /**
   * Contains information about this sound such as its length,
   * format, and type.
   * @see AudioFormat
   */
  private AudioFileFormat audioFileFormat = null;

  /**
   * A collection of the threads that are playing this sound.
   */
  private Vector<Playback> playbacks = new Vector<Playback>();

  /**
   * The explorer for this sound, if it exists. If it exists, this
   * becomes the LineListener for output lines in the Playback class.
   * @see Playback
   */
  private SoundExplorer soundExplorer = null;

  /**
   * The name of the file from which this sound was created.  Gets
   * updated every time load from file is called.
   * @see #loadFromFile
   */
  private String fileName = null;

  ////////////////////////// constructors /////////////////////

  /**
   * Constructs a <code>SimpleSound</code> of 3 seconds long.
   */
  public SimpleSound()
  {
    this(SAMPLE_RATE * 3);
  }

  /**
   * Constructs a <code>SimpleSound</code> of the specified length.
   * This sound will simply consist of an empty byte array, and an
   * <code>AudioFileFormat</code> with the following values:
   * <ul>
   * <li><code>AudioFileFormat.Type.WAVE</code>
   * <li>22.05K sampling rate
   * <li>16 bit sample
   * <li>1 channel
   * <li>signed PCM encoding
   * <li>small-endian byte order
   * </ul>
   * Note that no new sound file is created, we only represent the
   * sound with a buffer and the AudioFileFormat.  If a file is
   * desired, then the method <code>writeToFile(String filename)
   * </code> must be called on this newly created sound.
   *
   * @param numFrames the number of samples in the sound
   * @see SimpleSound#write(String filename)
   */
  public SimpleSound(int numFrames)
  {
    int numChannels = 1;    // the number of channels in the sound
    int bytesPerSample = NUM_BITS_PER_SAMPLE / 8;

    /*
     Make a new sound with the default sampling rate, 16 bits,
     1 channel(==1 sample/frame), signed, smallEndian
     */
    AudioFormat audioFormat =
      new AudioFormat(SAMPLE_RATE, NUM_BITS_PER_SAMPLE,
                      numChannels, true, false);

    /*
     * The length in bytes is the number of channels
     * times the number of frames and times the number of bytes per
     * sample (2 bytes per sample)
     */
    int lengthInFrames = numChannels * numFrames;
    int lengthInBytes = lengthInFrames * bytesPerSample;

    /*
     Make a new WAV file format, with the AudioFormat described above
     */
    audioFileFormat =
      new AudioFileFormat(AudioFileFormat.Type.WAVE,
                          audioFormat, lengthInFrames);

    // create the buffer
    buffer = new byte[lengthInBytes];

  }

  /**
   * Constructs a <code>SimpleSound</code> of the specified length.
   * This sound will simply consist of an empty byte array, and an
   * <code>AudioFileFormat</code> with the following values:
   * <ul>
   * <li><code>AudioFileFormat.Type.WAVE</code>
   * <li>22.05K sampling rate
   * <li>16 bit sample
   * <li>1 channel
   * <li>signed PCM encoding
   * <li>small-endian byte order
   * </ul>
   * Note that no new sound file is created, we only represent the
   * sound with a buffer and the AudioFileFormat.  If a file is
   * desired, then the method <code>writeToFile(String filename)
   * </code> must be called on this newly created sound.
   *
   * @param numFrames the number of samples in the sound
   * @see SimpleSound#write(String filename)
   */
  public SimpleSound(int numFrames, int sampleRate)
  {
    int numChannels = 1;    // the number of channels in the sound
    int bytesPerSample = NUM_BITS_PER_SAMPLE / 8;

    /*
     Make a new sound with the default sampling rate, 16 bits,
     1 channel(==1 sample/frame), signed, smallEndian
     */
    AudioFormat audioFormat =
      new AudioFormat(sampleRate, NUM_BITS_PER_SAMPLE,
                      numChannels, true, false);

    /*
     * The length in bytes is the number of channels
     * times the number of frames and times the number of bytes per
     * sample (2 bytes per sample)
     */
    int lengthInFrames = numChannels * numFrames;
    int lengthInBytes = lengthInFrames * bytesPerSample;

    /*
     Make a new WAV file format, with the AudioFormat described above
     */
    audioFileFormat =
      new AudioFileFormat(AudioFileFormat.Type.WAVE,
                          audioFormat, lengthInFrames);

    // create the buffer
    buffer = new byte[lengthInBytes];

  }

  /**
   * Constructs a simple sound with the given sample size in bits and
   * type of endian (big or little)
   */
  public SimpleSound(int sampleSizeInBits, boolean isBigEndian)
  {
    // calculate the number of bytes in the sample
    int numBytesInSample = sampleSizeInBits/8;
    int numberOfChannels = 1;
    boolean signedFlag = true;

    // create the audio format
    AudioFormat audioFormat =
      new AudioFormat(SAMPLE_RATE, sampleSizeInBits,
                      numberOfChannels,
                      signedFlag, isBigEndian);

    // compute the length of the byte array
    int lengthInBytes =
      SAMPLE_RATE*numberOfChannels*5*numBytesInSample;

    // create the audio file format
    audioFileFormat =
      new AudioFileFormat(AudioFileFormat.Type.WAVE,
                          audioFormat,
                          lengthInBytes/
                          (numBytesInSample*numberOfChannels));

    // create the buffer
    buffer = new byte[lengthInBytes];
  }

  /**
   * Constructs a new SimpleSound from the given file.
   * @param fileName The File from which to create this sound.
   * @see SimpleSound#loadFromFile(String filename)
   */
  public SimpleSound(String fileName) throws SoundException
  {
    try {
      // load the sound from the file
      loadFromFile(fileName);
    } catch (Exception ex) {
      printError("Exception during load of file " + fileName + "\n Please ensure this file exists and uses a filetype supported by JES (wav, aiff, au).");
    }
  }

  /**
   * Constructor that creates a new SimpleSound by copying a passed SimpleSound
   * @param sound the sound to copy
   */
  public SimpleSound(SimpleSound sound)
  {
    this.audioFileFormat = sound.audioFileFormat;
    this.fileName = sound.fileName;
    this.playbacks = new Vector<Playback>();

    // copy the samples
    if (sound.buffer != null)
    {
      this.buffer = new byte[sound.buffer.length];
      for (int i = 0; i < sound.buffer.length; i++)
        this.buffer[i] = sound.buffer[i];
    }
  }

  ///////////////////////// accessors ///////////////////////////

  /**
   * Method that returns the byte array representation of this simple sound.
   * @return the sound represented as a byte array
   */
  public byte[] getBuffer()
  {
    return buffer;
  }

  /**
   * Method that returns the AudioFileFormat describing this simple sound.
   * @return the AudioFileFormat describing this sound
   * @see AudioFileFormat
   */
  public AudioFileFormat getAudioFileFormat()
  {
    return audioFileFormat;
  }

  /**
   * Method to get the sampling rate of this sound
   * @return the sampling rate in number of samples per second
   */
  public double getSamplingRate()
  {
    return audioFileFormat.getFormat().getSampleRate();
  }

  /**
   * Method that returns the SoundExplorer
   * @return the sound explorer
   */
  public SoundExplorer getSoundExplorer()
  {
    return soundExplorer;
  }

  /**
   * Method to return the byte array
   * @return an array of bytes which represents the simple sound
   * @see SimpleSound#getBuffer
   */
  public byte[] asArray()
  {
    return getBuffer();
  }

  /**
   * Method that returns the vector of playback threads currently
   * active on this sound.
   * @return the vector of playback threads for this simple sound
   */
  public Vector getPlaybacks()
  {
    return playbacks;
  }

  /**
   * Method that returns the name of the file this sound came from.
   * If this sound did not originate with a file, this value will
   * be null.
   * @return the file name associated with this sound or null
   * @see #loadFromFile(String fileName)
   */
  public String getFileName()
  {
    return fileName;
  }

  ////////////////////////////// modifiers ////////////////////////

  /**
   * Changes the byte array that represents this sound.
   * @param newBuffer a byte array representation of the new sound we
   * want this to represent.
   */
  public void setBuffer(byte[] newBuffer)
  {
    buffer = newBuffer;
  }

  /**
   * Changes the byte array that represents this sound.
   * @param newBuffer an integer with the number of bytes in the buffer
   */
  public void setBuffer(int newBuffer)
  {
    buffer = new byte[newBuffer];
  }

  /**
   * Changes the AudioFileFormat of this sound.
   * @param newAudioFileFormat the new audioFileFormat that describes
   * this sound.
   * @see AudioFileFormat
   */
  public void setAudioFileFormat(AudioFileFormat newAudioFileFormat)
  {
    audioFileFormat = newAudioFileFormat;
  }

  /**
   * Changes the explorer of this object.
   * @param soundExplorer the new SoundExplorer to use
   * @see SoundExplorer
   */
  public void setSoundExplorer(SoundExplorer soundExplorer)
  {
    this.soundExplorer = soundExplorer;
  }



  ///////////////////////// methods /////////////////////////////

  /**
   * Creates an <code>AudioInputStream</code> for this sound from the
   * <code>buffer</code> and the <code>audioFileFormat</code>.
   * @return an AudioInputStream representing this sound.
   * @see AudioInputStream
   */
  public AudioInputStream makeAIS()
  {
    AudioFileFormat.Type fileType = audioFileFormat.getType();
    ByteArrayInputStream bais = new ByteArrayInputStream(buffer);
    int frameSize = audioFileFormat.getFormat().getFrameSize();

    AudioInputStream audioInputStream =
      new AudioInputStream(bais, audioFileFormat.getFormat(),
                           buffer.length/frameSize);
    return audioInputStream;
  }

  /**
   * Invokes <code>printError(message, null)</code>
   *
   * @see SimpleSound#printError(String message, Exception e)
   * @throws SoundException Will throw under every circumstance.
   *                            This way we can catch the exception
   *                            in JES.
   */
  public void printError(String message) throws SoundException
  {
    printError(message, null);
  }

  /**
   * Prints the given String to the "standard" error output stream, then
   * prints a stack trace on the exception, and then exits the program.  If
   * the String is null, then nothing happens, the method just returns.  If
   * the Exception is null, then it prints the String and then exits the
   * program.
   *
   * @param message A description of the error
   * @param e The exception, if any, that was caught regarding the error
   * @throws SoundException Will throw under every circumstance.
   *                            This way we can catch the exception
   *                            in JES.
   */
  public void printError(String message, Exception e) throws SoundException
  {
    if(message != null)
    {
      //SimpleOutput.showError(message);
      System.err.println(message);
      if(e != null)
      {
        e.printStackTrace();
      }
      //so we can catch the error
      throw(new SoundException(message));
    }
  }

  /**
   * Method to check if a sound is stereo (2 channels) or not
   * @return true if in stereo else false
   */
  public boolean isStereo()
  {
    if(audioFileFormat.getFormat().getChannels() == 1)
      return false;
    else
      return true;
  }

  ////////////////////////// File I/O ///////////////////////////////////

  /**
   * Method to write this sound to a file
   * @param fileName the name of the file to write to
   */
  public void write(String fileName) throws SoundException
  {
    try {
      writeToFile(fileName);
    }
    catch (SoundException ex) {
      printError("Couldn't write file to " + fileName);
    }
  }

  /**
   * Creates an audioInputStream from this sound, and then writes
   * this stream out to the file with the specified name.  If no
   * file exists, one is created.  If a file already exists, then it
   * is overwritten.  This does not check the extension of the
   * fileName passed in to make sure it agrees with the
   * <code>AudioFileFormat.Type</code> of this sound.
   *
   * @param outFileName The name of the file to write this sound to
   * @throws SoundException if any error is encountered while
   * writing to the file.
   */
  public void writeToFile(String outFileName)
    throws SoundException
  {

    /*
     get an audioInputStream that represents this sound.
     then, we will write from the stream to the file
     */
    AudioInputStream audioInputStream = makeAIS();
    AudioFileFormat.Type type = audioFileFormat.getType();

    try {
      audioInputStream.reset();
    }//try reset audioInputStream
    catch(Exception e)
    {
      printError("Unable to reset the Audio stream.  Please "+
                 "try again.", e);
    }//catch


    //get the file to write to
    File file = new File(outFileName);
    if(!file.exists())
    {
      //if the file doesn't exist, make one
      try
      {
        file.createNewFile();
      }//try
      catch(IOException e)
      {
        printError("That file does not already exist, and"+
                   "there were problems creating a new file" +
                   "of that name.  Are you sure the path" +
                   "to: " + outFileName + "exists?", e);
      }//catch
    }//if


    //write to the file
    try
    {
      if(AudioSystem.write(audioInputStream, type, file) == -1)
      {
        printError("Problems writing to file.  Please " +
                   "try again.");
      }

      // if the write was successful then set the file name to the
      // new name
      else
      {
        this.fileName = outFileName;
      }
    }//try
    catch(FileNotFoundException e)
    {
      printError("The file you specified did not already exist " +
                 "so we tried to create a new one, but were unable"+
                 "to do so.  Please try again.  If problems "+
                 "persit see your TA.", e);
    }
    catch(Exception e)
    {
      printError("Problems writing to file: " + outFileName, e);
    }//catch


    //close the input stream, we're done writing
    try
    {
      audioInputStream.close();
    }//try
    catch(Exception e)
    {
      printError("Unable to close the Audio stream.");
    }//catch

  }//writeToFile(String outFileName)


  /**
   * Resets the fields of this sound so that it now represents the
   * sound in the specified file.  If successful, the fileName
   * ariable is updated such that it is equivalent to
   * <code>inFileName</code>.
   *
   * @param inFileName the path and filename of the sound we want to
   *                   represent.
   * @throws SoundException if any problem is encountered while
   *                            reading in from the file.
   */
  public void loadFromFile(String inFileName) throws SoundException
  {

    // try to prevent a null pointer exception
    if(inFileName == null)
    {
      printError("You must pass in a valid file name.  Please try" +
                 "again.");
    }

    /* get the File object representing the file named inFileName
     * and make sure it exists */
    File file = new File(inFileName);
    if(!file.exists())
    {
      printError("The file: " + inFileName + " doesn't exist");
    }

    // create an audioInputStream from this file

    AudioInputStream audioInputStream;
    try {
      audioInputStream = AudioSystem.getAudioInputStream(file);
    } catch(Exception e) {
      printError("Unable to read from file " +
                 inFileName + ".  The file type is unsupported.  " +
                 "Are you sure you're using a WAV, AU, or " +
                 "AIFF file (some .wav files are encoded " +
                 "using mp3)?  Try using SimpleSound.convert(" +
                 "String oldName, String newName) and then " +
                 "try to read the new name.", e);
      return;
    }//catch

    /* We need to make an array representing this sound, so the
     * number of bytes we will be storing cannot be greater than
     * Integer.MAX_VALUE.  The JavaSound API also supports only
     * integer length frame lengths.
     * (See AudioFileFormat.getFrameLength().  I don't know why
     * this is inconsistent with AudioInputStream.getFrameLength().)
     */
    if((audioInputStream.getFrameLength() *
        audioInputStream.getFormat().getFrameSize()) >
       Integer.MAX_VALUE)
    {
      printError("The sound in file: " + inFileName +
                 " is too long."+
                 "  Try using a shorter sound.");
    }
    int bufferSize = (int)audioInputStream.getFrameLength() *
      audioInputStream.getFormat().getFrameSize();

    buffer = new byte[bufferSize];

    int numBytesRead = 0;
    int offset = 0;

    //read all the bytes into the buffer
    while(true)
    {
      try {
        numBytesRead =
          audioInputStream.read(buffer, offset, bufferSize);
        if(numBytesRead == -1)//no more data
          break;
        else
          offset += numBytesRead;
      } catch(Exception e) {
        printError("Problems reading the input stream.  "+
                   "You might want to try again using this "+
                   " file: " + inFileName + "or a different"+
                   " file.  If problems persist, ask your TA."
                     , e);
      }//catch
    }//while


    /* set the format of the file, assuming that the extension
     * is correct
     */
    if(inFileName.toLowerCase().endsWith(".wav"))
    {
      audioFileFormat =
        new AudioFileFormat(AudioFileFormat.Type.WAVE,
                            audioInputStream.getFormat(),
                            (int)audioInputStream.getFrameLength());
    }
    else if(inFileName.toLowerCase().endsWith(".au"))
    {
      audioFileFormat =
        new AudioFileFormat(AudioFileFormat.Type.AU,
                            audioInputStream.getFormat(),
                            (int)audioInputStream.getFrameLength());
    }
    else if (inFileName.toLowerCase().endsWith(".aif")||
             inFileName.toLowerCase().endsWith(".aiff"))
    {
      audioFileFormat =
        new AudioFileFormat(AudioFileFormat.Type.AIFF,
                            audioInputStream.getFormat(),
                            (int)audioInputStream.getFrameLength());
    }
    else
    {
      printError("Unsupported file type.  Please try again with a "+
                 "file that ends in .wav, .au, .aif, or .aiff");
    }

    if(DEBUG)
    {
      System.out.println("New sound created from file: " + fileName);
      System.out.println("\tendianness: " +
                         audioInputStream.getFormat().isBigEndian());
      System.out.println("\tencoding: " +
                         audioInputStream.getFormat().getEncoding());
    }

    this.fileName = inFileName;

  }//loadFromFile(String inFileName)

  //////////////////////// Methods for playing the sound //////////

  /**
   * Creates a new Playback thread and starts it.  The thread is
   * guaranteed to finish playing the sound as long as the program
   * doesn't exit before it is done.  This method does not block,
   * however.  So, if you invoke <code>play()</code> multiple times
   * in a row, sounds will simply play on
   * top of eachother - "accidental mixing"
   *
   * @see Playback
   */
  public void play()
  {
    // create the thread, add it to the Vector, and start it
    Playback playback = new Playback(this);
    playbacks.add(playback);
    playback.start();
  }

  /**
   * Creates a new Playback thread, starts it, then waits for the
   * entire sound to finish playing before it returns.  This method
   * is guarranteed to play the entire sound, and does not allow for
   * any "accidental mixing"
   *
   * @see Playback
   */
  public void blockingPlayOld()
  {
    /* create the thread, add it to the Vector, start it, and wait
     until its done playing to return */
    Playback playback = new Playback(this);
    playbacks.add(playback);
    playback.start();
    //wait until the sound is done playing
    while(playback.isAlive()){;}
  }

  /**
   * Plays the sound, then sleeps for how
   * long the sound SHOULD last.
   **/
  public void blockingPlay()
  {
    this.play();
    try {
      double timeToSleep =
           1000 *
        (this.getLength()/this.getSamplingRate());
      Thread.sleep((int) timeToSleep);
    } catch (Exception ex) {
      System.out.println("Exception occurred: "+ex);
    }
  }

  /**
   * Checks the value of durInFrames to make sure that it is not
   * larger than Integer.MAX_VALUE to guarrantee safe casting.
   * Also checks the value of rate to make sure that it is not
   * larger than Float.MAX_VALUE before casting.
   *
   * @param rate a double representing the change in sampleRate
   * (==frameRate) for playing back this sound
   * @param durInFrames a double representing how much of this
   * sound we want to play.
   * @see SimpleSound#playAtRateInRange(float rate,
   *                                    int startFrame,
   *                                    int endFrame,
   *                                    boolean isBlocking)
   * @throws SoundException if there are problems playing the sound.
   */
  public void playAtRateDur(double rate, double durInFrames)
    throws SoundException
  {
    if(durInFrames > getLengthInFrames())
    {
      printError("The given duration in frames, " + durInFrames +
                 " is out of the playable range.  Try something " +
                 "between 1 and " + getLengthInFrames());
    }
    if(rate > Float.MAX_VALUE)
    {
      printError("The new sample rate, " + rate + "is out of the " +
                 "playable range.  Try something between " +
                 "0 and " + Float.MAX_VALUE);
    }
    playAtRateInRange((float)rate, 0, (int)durInFrames-1, false);
  }

  /**
   * First, checks the value of durInFrames to make sure that it is
   * not larger than Integer.MAX_VALUE to guarrantee safe casting.
   * Simmilarly, checks the value of rate to make sure that it is
   * not larger than FLoat.MAX_VALUE before casting.
   *
   * @param rate a double representing the change in sampleRate
   * (==frameRate) for playing back this sound
   * @param durInFrames a double representing how much of this sound
   * we want to play
   * @see SimpleSound#playAtRateInRange(float range,
   *                                    int startFrame,
   *                                    int endFrame,
   *                                    boolean isBlocking)
   * @throws SoundException if there are problems playing the sound.
   */
  public void blockingPlayAtRateDur(double rate, double durInFrames)
    throws SoundException
  {
    if(durInFrames > getLengthInFrames())
    {
      printError("The given duration in frames, " + durInFrames +
                 " is out of the playable range.  Try something " +
                 "between 1 and " + getLengthInFrames());
    }
    if(rate > Float.MAX_VALUE)
    {
      printError("The new sample rate, " + rate + "is out of the " +
                 "playable range.  Try something between " +
                 "0 and " + Float.MAX_VALUE);
    }

    playAtRateInRange((float)rate, 0, (int)durInFrames-1, true);

  }

  /**
   * Calls <code>playAtRateInRange(rate, startFrame, endFrame,
   * false) </code>.
   *
   * @param rate a float representing the change in sampleRate
   * (==frameRate) for playing back this sound
   * @param startFrame an int representing the frame at which we
   * want to begin playing the sound
   * @param endFrame an int representing the frame at which want
   * to stop playing the sound
   * @see SimpleSound#playAtRateInRange(float range,
   *                                    int startFrame,
   *                                    int endFrame,
   *                                    boolean isBlocking)
   * @throws SoundException if there are problems playing the sound.
   */
  public void playAtRateInRange(float rate, int startFrame,
                                int endFrame)
    throws SoundException
  {
    playAtRateInRange(rate, startFrame, endFrame, false);
  }

  /**
   * Calls <code>playAtRateInRange(rate, startFrame, endFrame, true)
   * </code>.
   *
   * @param rate a float representing the change in sampleRate
   * (==frameRate) for playing back this sound
   * @param startFrame an int representing the frame at which we want
   * to begin playing the sound
   * @param endFrame an int representing the frame at which want
   * to stop playing the sound
   * @see SimpleSound#playAtRateInRange(float range,
   *                                    int startFrame,
   *                                    int endFrame,
   *                                    boolean isBlocking)
   * @throws SoundException if there are problems playing the sound.
   */
  public void blockingPlayAtRateInRange(float rate, int startFrame,
                                        int endFrame)
    throws SoundException
  {
    playAtRateInRange(rate, startFrame, endFrame, true);
  }

  /**
   * Plays the specified segment of this sound at the given sample
   * rate.  Then it saves the old fields (buffer and audioFileFormat)
   * of this sound into temporary variables, and setting the fields
   * of this sound to modified values.  Then it creates a Playback
   * thread on this sound (with the modified values) and starts the
   * thread.  The values for buffer and audioFileFormat are restored
   * to their original values before the method returns.
   *
   * @param rate The change in the sampleRate (==frameRate) for
   * playing back this sound.  The old SampleRate is multiplied by
   * this value.  So, if rate = 2, the sound will play twice as fast
   * (half the length), and if rate = .5, the sound will play half as
   *             fast (twice the length).
   * @param startFrame The index of the frame where we want to begin
   * play
   * @param endFrame The index of the frame where we want to end play
   * @param isBlocking If true, this method waits until the thread is
   * done playing the sound before returning.  If false, it
   *                   simply starts the thread and then returns.
   * @throws SoundException if there are any problems playing the
   * sound.
   */
  public void playAtRateInRange(float rate, int startFrame,
                                int endFrame, boolean isBlocking)
    throws SoundException
  {

    /*before we get started, lets try to check for some obvious
     * errors.  maybe we can avoid some of those pesky array out of
     * bounds exceptions.
     */
    if(endFrame >= getAudioFileFormat().getFrameLength())
    {
      printError("You are trying to play to index: " + (endFrame+_SoundIndexOffset) +
                 ".  The sound only has " +
                 getAudioFileFormat().getFrameLength() +
                 " samples total.");
    }
    if(startFrame < _SoundIndexOffset)
    {
      printError("You cannot start playing at index " +
                 (startFrame+_SoundIndexOffset) +
                 ".  Choose " + _SoundIndexOffset + " to start at the begining.");
    }
    if(endFrame < startFrame)
    {
      printError("You cannot start playing at index " +
                 (startFrame+_SoundIndexOffset) + " and stop playing at index " +
                 (endFrame+_SoundIndexOffset) + ".  The start index must be before" +
                 "the stop index.");
    }


    /*
     we want to save the current buffer and audioFileFormat
     so we can return to them when we're finished.
     */
    byte[] oldBuffer = buffer;
    AudioFileFormat oldAFF = getAudioFileFormat();

    //just to make the code easier to read
    int frameSize = getAudioFileFormat().getFormat().getFrameSize();
    int durInFrames = (endFrame - startFrame) + 1;
    if(DEBUG)
      System.out.println("\tnew durInFrames = " + durInFrames);

    //we want to make a new buffer, only as long as we need
    int newBufferSize = durInFrames * frameSize;

    byte[] newBuffer = new byte[newBufferSize];
    for(int i = 0; i <  newBufferSize; i++)
    {
      newBuffer[i] = oldBuffer[(startFrame*frameSize) + i];
    }

    //now we want to make a new audioFormat with the same information
    //except a different rate
    AudioFormat newAF =
      new AudioFormat(oldAFF.getFormat().getEncoding(),
                      oldAFF.getFormat().getSampleRate() * rate,
                      oldAFF.getFormat().getSampleSizeInBits(),
                      oldAFF.getFormat().getChannels(),
                      oldAFF.getFormat().getFrameSize(),
                      oldAFF.getFormat().getFrameRate() * rate,
                      oldAFF.getFormat().isBigEndian());

    //now put that new AudioFormat into a new AudioFileFormat with
    //the changed duration in frames
    AudioFileFormat newAFF =
      new AudioFileFormat(oldAFF.getType(), newAF, durInFrames);


    /*
     change the values in this Sound
     */
    setBuffer(newBuffer);
    setAudioFileFormat(newAFF);
    if(DEBUG)
    {
      System.out.println("playAtRateInRange(" + rate + ", " +
                         startFrame + ", " + endFrame + ", " +
                         isBlocking + ")");
      System.out.println("\t(length of sound = " +
                         getAudioFileFormat().getFrameLength() + ")");
    }

    /*
     play the modified sound
     */
    Playback playback = new Playback(this);
    playbacks.add(playback);
    playback.start();

    if(isBlocking)
      while(playback.isAlive()){;}//wait until the thread exits

    /*
     we need to wait until the thread is done with the values
     before we change them back.  The playing flag is set to false
     until the loop begins in which data is actually written out.
     see Playback#run()
     */
    while(!playback.getPlaying()){;}

    setBuffer(oldBuffer);//restore the buffer
    setAudioFileFormat(oldAFF);//restore the file format
  }

  /**
   * Stops playing the sound by calling the stopPlaying()
   * method of all Playback threads belonging to the sound.
   */
  public void stopPlaying()
  {
    //stop all playback threads related to this sound
    for(int i = 0; i < this.getPlaybacks().size(); i++)
    {
      ((Playback)this.getPlaybacks().elementAt(i)).stopPlaying();
    }
  }

  /**
   * Deletes the specified playback object from the Vector.  This
   * should only be called from within the run() method of an
   * individual playback thread.
   *
   * @see Playback#run()
   */
  public void removePlayback(Playback playbackToRemove)
  {
    if(playbacks.contains(playbackToRemove))
    {
      playbacks.remove(playbackToRemove);
      playbackToRemove = null;
    }
  }




  ////////////////////// getting sound information /////////////////

  /**
   * Returns an array containing all of the bytes in the specified
   * frame.
   *
   * @param frameNum the index of the frame to access
   * @return the array containing all of the bytes in frame
   *         <code>frameNum</code>
   * @throws SoundException if the frame number is invalid.
   */
  public byte[] getFrame(int frameNum) throws SoundException
  {
    if(frameNum >= getAudioFileFormat().getFrameLength())
    {
      printError("That index "+ (frameNum) +", does not exist. "+
                 "The last valid index is "+
                 (getAudioFileFormat().getFrameLength() -1));
    }

    int frameSize = getAudioFileFormat().getFormat().getFrameSize();
    byte[] theFrame = new byte[frameSize];
    for (int i = 0; i < frameSize; i++)
    {
      theFrame[i] = buffer[frameNum*frameSize+i];
    }
    return theFrame;
  }


  /**
   * Obtains the length of the audio data contained in the file,
   * expressed in sample frames.
   *
   * @return the number of sample frames of audio data in the file
   */
  public int getLengthInFrames()
  {
    return getAudioFileFormat().getFrameLength();
  }

  /**
   * Returns the number of samples in this sound
   * @return the number of sample frames
   */
  public int getNumSamples()
  {
    return getAudioFileFormat().getFrameLength();
  }

  /**
   * Method to create and return a SoundSample object for the given
   * frame number
   * @return a SoundSample object for this frame number
   */
  public SoundSample getSample(int frameNum)
  {
    return new SoundSample(this,frameNum);
  }

  /**
   * Method to create and return an array of SoundSample objects
   * @return the array of SoundSample objects
   */
  public SoundSample[] getSamples()
  {
    int numSamples = getLengthInFrames();
    SoundSample[] samples = new SoundSample[numSamples];
    for (int i=0; i < numSamples; i++)
      samples[i] = new SoundSample(this,i);
    return samples;
  }

  /**
   * Method to report an index exception for this sound
   * @param index the index
   * @param ex the exception (unused)
   */
  private void reportIndexException(int index, Exception ex)
  {
    System.out.println("The index " + index +
                       " isn't valid for this sound");
  }

  /**
   * Method to get the sample at the passed index and handle
   * any SoundExceptions
   * @param index the desired index
   * @return the sample value
   */
  public int getSampleValueAt(int index)
  {
    int value = 0;

    try {
      value = getSampleValue(index);
    } catch (Exception ex) {
      reportIndexException(index, ex);
    }
    return value;
  }

  /**
   * If this is a mono sound, obtains the single sample contained
   * within this frame, else obtains the first (left) sample
   * contained in the specified frame.
   *
   * @param frameNum the index of the frame to access
   * @return an integer representation of the bytes contained within
   * the specified frame
   * @throws SoundException if the frame number is invalid.
   */
  public int getSampleValue(int frameNum) throws SoundException
  {
    //Before we get started, lets make sure that frame exists
    if(frameNum >= getAudioFileFormat().getFrameLength())
    {
      printError("You are trying to access the sample at index: "
                 + (frameNum) + ", but the last valid index is at " +
                 (getAudioFileFormat().getFrameLength() - 1));
    }
    else if(frameNum < 0)
    {
      printError("You asked for the sample at index: " + (frameNum) +
                 ".  This number is less than zero.  Please try" +
                 "again using an index in the range [0," +
                 (getAudioFileFormat().getFrameLength() - 1) +"]");
    }

    AudioFormat format = getAudioFileFormat().getFormat();
    int sampleSizeInBits = format.getSampleSizeInBits();
    boolean isBigEndian = format.isBigEndian();

    byte[] theFrame = getFrame(frameNum);

    if(format.getEncoding().equals(AudioFormat.Encoding.PCM_SIGNED))
    {
      //since we're always returning the left sample,
      //we don't care if we're mono or stereo, left is
      //always first in the frame
      if(sampleSizeInBits == 8)//8 bits == 1 byte
        return theFrame[0];
      else if(sampleSizeInBits == 16)
        return TConversionTool.bytesToInt16(theFrame, 0,
                                            isBigEndian);
      else if(sampleSizeInBits == 24)
        return TConversionTool.bytesToInt24(theFrame, 0,
                                            isBigEndian);
      else if(sampleSizeInBits == 32)
        return TConversionTool.bytesToInt32(theFrame, 0,
                                            isBigEndian);
      else
      {
        printError("Unsupported audio encoding.  The sample "+
                   "size is not recognized as a standard "+
                   "format.");
        return -1;
      }
    }
    else if(format.getEncoding().equals(AudioFormat.Encoding.PCM_UNSIGNED))
    {
      if(sampleSizeInBits == 8)
        return TConversionTool.unsignedByteToInt(theFrame[0])-
        (int)Math.pow(2,7);
      else if(sampleSizeInBits == 16)
        return TConversionTool.unsignedByteToInt16(theFrame, 0,
                                                   isBigEndian)-
        (int)Math.pow(2, 15);
      else if(sampleSizeInBits == 24)
        return TConversionTool.unsignedByteToInt24(theFrame, 0,
                                                   isBigEndian)-
        (int)Math.pow(2, 23);
      else if(sampleSizeInBits == 32)
        return TConversionTool.unsignedByteToInt32(theFrame, 0,
                                                   isBigEndian)-
        (int)Math.pow(2, 31);
      else
      {
        printError("Unsupported audio encoding.  The sample "+
                   "size is not recognized as a standard "+
                   "format.");
        return -1;
      }
    }
    else if(format.getEncoding().equals(AudioFormat.Encoding.ALAW))
    {
      return TConversionTool.alaw2linear(buffer[0]);
    }
    else if(format.getEncoding().equals(AudioFormat.Encoding.ULAW))
    {
      return TConversionTool.ulaw2linear(buffer[0]);
    }
    else
    {
      printError("unsupported audio encoding: " +
                 format.getEncoding() + ".  Currently only PCM, " +
                 "ALAW and ULAW are supported.  Please try again" +
                 "with a different file.");
      return -1;
    }
  }//getSample(int)

  /**
   * Obtains the left sample of the audio data contained at the specified
   * frame.
   *
   * @param frameNum the index of the frame to access
   * @return an int representation of the bytes contained in the specified
   *         frame.
   * @throws SoundException if the frameNumber is invalid
   */
  public int getLeftSample(int frameNum) throws SoundException
  {
    //default is to getLeftSample

    return getSampleValue(frameNum);
  }

  /**
   * Obtains the right sample of the audio data contained at the specified
   * frame.
   *
   * @param frameNum the index of the frame to access
   * @return an int representation of the bytes contained in the specified
   *         frame.
   * @throws SoundException if the frameNumber is invalid, or
   *                            the encoding isn't supported.
   */
  public int getRightSample(int frameNum) throws SoundException
  {
    //Before we get started, lets make sure that frame exists
    if(frameNum >= getAudioFileFormat().getFrameLength())
    {
      printError("You are trying to access the sample at index: "
                   + (frameNum) + ", but the last valid index is at " +
                 (getAudioFileFormat().getFrameLength() - 1));
    }
    else if(frameNum < 0)
    {
      printError("You asked for the sample at index: "+(frameNum+1) +
                 ".  This number is less than zero.  Please try" +
                 " again using an index in the range [0," +
                 (getAudioFileFormat().getFrameLength()-1) + "].");
    }

    AudioFormat format = getAudioFileFormat().getFormat();
    int channels;
    if((channels = format.getChannels())==1)
    {
      printError("Only stereo sounds have different right and left" +
                 " samples.  You are using a mono sound, try " +
                 "getSample("+(frameNum)+") instead");
      return -1;
    }
    int sampleSizeInBits = format.getSampleSizeInBits();
    boolean isBigEndian = format.isBigEndian();

    byte[] theFrame = getFrame(frameNum);

    if(format.getEncoding().equals(AudioFormat.Encoding.PCM_SIGNED))
    {
      if(sampleSizeInBits == 8)//8 bits == 1 byte
        return theFrame[1];
      else if(sampleSizeInBits == 16)
        return TConversionTool.bytesToInt16(theFrame, 2, isBigEndian);
      else if(sampleSizeInBits == 24)
        return TConversionTool.bytesToInt24(theFrame, 3, isBigEndian);
      else if(sampleSizeInBits == 32)
        return TConversionTool.bytesToInt32(theFrame, 4, isBigEndian);
      else
      {
        printError("Unsupported audio encoding.  The sample"+
                   " size is not recognized as a standard"+
                   " format.");
        return -1;
      }
    }
    else if(format.getEncoding().equals(AudioFormat.Encoding.PCM_UNSIGNED))
    {
      if(sampleSizeInBits == 8)
        return TConversionTool.unsignedByteToInt(theFrame[1]);
      else if(sampleSizeInBits == 16)
        return TConversionTool.unsignedByteToInt16(theFrame, 2, isBigEndian);
      else if(sampleSizeInBits == 24)
        return TConversionTool.unsignedByteToInt24(theFrame, 3, isBigEndian);
      else if(sampleSizeInBits == 32)
        return TConversionTool.unsignedByteToInt32(theFrame, 4, isBigEndian);
      else
      {
        printError("Unsupported audio encoding.  The sample"+
                   " size is not recognized as a standard" +
                   " format.");
        return -1;
      }
    }
    else if(format.getEncoding().equals(AudioFormat.Encoding.ALAW))
    {
      return TConversionTool.alaw2linear(buffer[1]);
    }
    else if(format.getEncoding().equals(AudioFormat.Encoding.ULAW))
    {
      return TConversionTool.ulaw2linear(buffer[1]);
    }
    else
    {
      printError("unsupported audio encoding: " +
                 format.getEncoding() + ".  Currently only PCM, " +
                 "ALAW and ULAW are supported.  Please try again" +
                 "with a different file.");
      return -1;
    }
  }



  /**
   * Obtains the length of this sound in bytes.  Note, that this number is not
   * neccessarily the same as the length of this sound's file in bytes.
   *
   * @return the sound length in bytes
   */
  public int getLengthInBytes()
  {
    return buffer.length;
  }

  /**
   * Method to return the length of the sound as the number of samples
   * @return the length of the sound as the number of samples
   */
  public int getLength()
  {
    return getNumSamples();
  }

  /**
   * Obtains the number of channels of this sound.
   *
   * @return the number of channels (1 for mono, 2 for stereo), or
   * <code>AudioSystem.NOT_SPECIFIED</code>
   * @see AudioSystem#NOT_SPECIFIED
   */
  public int getChannels()
  {
    return getAudioFileFormat().getFormat().getChannels();
  }


  /**************************************************************************/
  /************************** CHANGING THE SOUND ****************************/
  /**************************************************************************/

  /**
   * Changes the value of each byte of the specified frame.
   *
   * @param frameNum the index of the frame to change
   * @param theFrame the byte array that will be copied into this sound's
   *                 buffer in place of the specified frame.
   * @throws SoundException if the frameNumber is invalid.
   */
  public void setFrame(int frameNum, byte[] theFrame) throws SoundException
  {
    if(frameNum >= getAudioFileFormat().getFrameLength())
    {
      printError("That frame, number "+frameNum+", does not exist. "+
                 "The last valid frame number is " +
                 (getAudioFileFormat().getFrameLength() - 1));
    }
    int frameSize = getAudioFileFormat().getFormat().getFrameSize();
    if(frameSize != theFrame.length)
      printError("Frame size doesn't match, line 383.  This should" +
                 " never happen.  Please report the problem to a TA.");
    for(int i = 0; i < frameSize; i++)
    {
      buffer[frameNum*frameSize+i] = theFrame[i];
    }
  }

  /**
   * Method to set the sample value at the passed index to the passed value
   * @param index the index
   * @param value the new value
   */
  public void setSampleValueAt(int index, int value)
  {
    try {
      setSampleValue(index,value);
    } catch (Exception ex) {
      reportIndexException(index,ex);
    }
  }

  /**
   * Changes the value of the sample found at the specified frame.  If this
   * sound has more than one channel, then this defaults to setting only the
   * first (left) sample.
   *
   * @param frameNum the index of the frame where the sample should be changed
   * @param sample an int representation of the new sample to put in this
   *               sound's buffer at the specified frame
   * @throws SoundException if the frameNumber is invalid, or
   *                            another problem is encountered
   */
  public void setSampleValue(int frameNum, int sample) throws SoundException
  {
    AudioFormat format = getAudioFileFormat().getFormat();
    int sampleSizeInBits = format.getSampleSizeInBits();
    boolean isBigEndian = format.isBigEndian();

    byte[] theFrame = getFrame(frameNum);

    if(format.getEncoding().equals(AudioFormat.Encoding.PCM_SIGNED))
    {
      if(sampleSizeInBits == 8)//8 bits = 1 byte = first cell in array
      {
        theFrame[0] = (byte)sample;
        setFrame(frameNum, theFrame);
      }
      else if(sampleSizeInBits == 16)//2 bytes, first 2 cells in array
      {
        TConversionTool.intToBytes16(sample, theFrame, 0, isBigEndian);
        setFrame(frameNum, theFrame);
      }
      else if(sampleSizeInBits == 24)
      {
        TConversionTool.intToBytes24(sample, theFrame, 0, isBigEndian);
        setFrame(frameNum, theFrame);
      }
      else if(sampleSizeInBits == 32)
      {
        TConversionTool.intToBytes32(sample, theFrame, 0, isBigEndian);
        setFrame(frameNum, theFrame);
      }
      else
      {
        printError("Unsupported audio encoding.  The sample"+
                   "size is not recognized as a standard format");
      }
    }//if format == PCM_SIGNED
    else if(format.getEncoding().equals(AudioFormat.Encoding.PCM_UNSIGNED))
    {
      if(sampleSizeInBits == 8)
      {
        theFrame[0] = TConversionTool.intToUnsignedByte(sample);
        setFrame(frameNum, theFrame);
      }
      else if(sampleSizeInBits == 16)
      {
        TConversionTool.intToUnsignedBytes16(sample, theFrame, 0, isBigEndian);
        setFrame(frameNum, theFrame);
      }
      else if(sampleSizeInBits == 24)
      {
        TConversionTool.intToUnsignedBytes24(sample, theFrame, 0, isBigEndian);
        setFrame(frameNum, theFrame);
      }
      else if(sampleSizeInBits == 32)
      {
        TConversionTool.intToUnsignedBytes32(sample, theFrame, 0, isBigEndian);
        setFrame(frameNum, theFrame);
      }

      else
      {
        printError("Unsupported audio encoding.  The sample"+
                   " size is not recognized as a standard "+
                   "format.");
      }
    }
    else if(format.getEncoding().equals(AudioFormat.Encoding.ALAW))
    {
      if((sample>Short.MAX_VALUE)||(sample<Short.MIN_VALUE))
        printError("You are trying to set the sample value to: "+
                   sample + ", but the maximum value for a sample"+
                   " in this format is: "+Short.MAX_VALUE+
                   ", and the minimum value is: "+Short.MIN_VALUE+
                   ".  Please choose a value in that range.");
      theFrame[0] = TConversionTool.linear2alaw((short)sample);
      setFrame(frameNum, theFrame);
    }
    else if(format.getEncoding().equals(AudioFormat.Encoding.ULAW))
    {

      if((sample>Short.MAX_VALUE)||(sample<Short.MIN_VALUE))
        printError("You are trying to set the sample value to: "+
                   sample + ", but the maximum value for a sample"+
                   " in this format is: "+Short.MAX_VALUE+
                   ", and the minimum value is: "+Short.MIN_VALUE+
                   ".  Please choose a value in that range.");
      theFrame[0] = TConversionTool.linear2ulaw((short)sample);
      setFrame(frameNum, theFrame);
    }
    else
    {
      printError("unsupported audio encoding: " +
                 format.getEncoding() + ".  Currently only PCM, " +
                 "ALAW and ULAW are supported.  Please try again" +
                 "with a different file.");
    }
  }//setSample(int, int)

  /**
   * Method to set the left sample value at the passed index to the passed value
   * @param frameNum the index of the frame where the sample should be changed
   * @param sample an integer representation of the new sample
   */
  public void setLeftSample(int frameNum, int sample) throws SoundException
  {
    setSampleValue(frameNum, sample);
  }

  /**
   * Method to set the right sample value at the passed index to the passed value
   * @param frameNum the index of the frame where the sample should be changed
   * @param sample an integer representation of the new sample
   */
  public void setRightSample(int frameNum, int sample) throws SoundException
  {
    AudioFormat format = getAudioFileFormat().getFormat();
    int sampleSizeInBits = format.getSampleSizeInBits();
    boolean isBigEndian = format.isBigEndian();

    if(format.getChannels() == 1)
      printError("this is a mono sound.  only stereo sounds have" +
                 " different left and right samples.");

    byte[] theFrame = getFrame(frameNum);

    if(format.getEncoding().equals(AudioFormat.Encoding.PCM_SIGNED))
    {
      //right will always be the second in the frame
      if(sampleSizeInBits == 8)
      {
        theFrame[1] = (byte)sample;
        setFrame(frameNum, theFrame);
      }
      else if(sampleSizeInBits == 16)
      {
        TConversionTool.intToBytes16(sample, theFrame, 2, isBigEndian);
        setFrame(frameNum, theFrame);
      }
      else if(sampleSizeInBits == 24)
      {
        TConversionTool.intToBytes24(sample, theFrame, 3, isBigEndian);
        setFrame(frameNum, theFrame);
      }
      else if(sampleSizeInBits == 32)
      {
        TConversionTool.intToBytes32(sample, theFrame, 4, isBigEndian);
        setFrame(frameNum, theFrame);
      }
      else
      {
        printError("Unsupported audio encoding.  The sample"+
                   "size is not recognized as a standard format");
      }
    }//if format == PCM_SIGNED
    else if(format.getEncoding().equals(AudioFormat.Encoding.PCM_UNSIGNED))
    {
      if(sampleSizeInBits == 8)
      {
        theFrame[1] = TConversionTool.intToUnsignedByte(sample);
        setFrame(frameNum, theFrame);
      }
      else if(sampleSizeInBits == 16)
      {
        TConversionTool.intToUnsignedBytes16(sample, theFrame, 2, isBigEndian);
        setFrame(frameNum, theFrame);
      }
      else if(sampleSizeInBits == 24)
      {
        TConversionTool.intToUnsignedBytes24(sample, theFrame, 3, isBigEndian);
        setFrame(frameNum, theFrame);
      }
      else if(sampleSizeInBits == 32)
      {
        TConversionTool.intToUnsignedBytes32(sample, theFrame, 4, isBigEndian);
        setFrame(frameNum, theFrame);
      }
      else
      {
        printError("Unsupported audio encoding.  The sample"+
                   " size is not recognized as a standard"+
                   " format");
      }
    }
    else if(format.getEncoding().equals(AudioFormat.Encoding.ALAW))
    {
      if((sample>Short.MAX_VALUE)||(sample<Short.MIN_VALUE))
        printError("You are trying to set the sample value to: "+
                   sample + ", but the maximum value for a sample"+
                   " in this format is: "+Short.MAX_VALUE+
                   ", and the minimum value is: "+Short.MIN_VALUE+
                   ".  Please choose a value in that range.");
      theFrame[1] = TConversionTool.linear2alaw((short)sample);
      setFrame(frameNum, theFrame);
    }
    else if(format.getEncoding().equals(AudioFormat.Encoding.ULAW))
    {
      if((sample>Short.MAX_VALUE)||(sample<Short.MIN_VALUE))
        printError("You are trying to set the sample value to: "+
                   sample + ", but the maximum value for a sample"+
                   " in this format is: "+Short.MAX_VALUE+
                   ", and the minimum value is: "+Short.MIN_VALUE+
                   ".  Please choose a value in that range.");
      theFrame[1] = TConversionTool.linear2ulaw((short)sample);
      setFrame(frameNum, theFrame);
    }
    else
    {
      printError("unsupported audio encoding: " +
                 format.getEncoding() + ".  Currently only PCM, " +
                 "ALAW and ULAW are supported.  Please try again" +
                 "with a different file.");
    }
  }//setRightSample(int, int)

  /**
   * Method to open a sound viewer on a copy of this sound
   */
  public void explore()
  {
    SimpleSound sound = new SimpleSound(this);
    new SoundExplorer(sound,this.isStereo());
  }

  //TODO: is there a reason this is here?
  /**
   * Method to play a note using MIDI
   * @param key the piano key to play
   * @param duration how long to play the note
   * @param intensity how hard to strike the note from (0-127)
   */
  public static void playNote(int key, int duration, int intensity)
  {
  }

  /**
   * Method to convert a mp3 sound into a wav sound
   * @param mp3File the file name of the mp3 to convert
   * @param wavFile the file name to save the wav to
   */
  public static void convert(String mp3File, String wavFile)
  {
    try {
      //Converter converter = new Converter();
      //converter.convert(mp3File,wavFile);
    } catch (Exception ex) {
      SimpleOutput.showError("Couldn't covert the file " + mp3File);
    }
  }

  ////////////////////// String methods ///////////////////////////////

  /**
   * Obtains a string representation of this JavaSound.
   * @return a String representation of this JavaSound.
   */
  public String toString()
  {
    String output = "SimpleSound";

    // if there is a file name then add that to the output
    if (fileName != null)
      output = output + " file: " + fileName;

    // add the length
    output = output + " length: " + getLengthInBytes();

    return output;
  }

} // end of SimpleSound class
/**
 * Class that represents a sound.  This class is used by the students
 * to extend the capabilities of SimpleSound.
 * <br>
 * Copyright Georgia Institute of Technology 2004
 * @author Barbara Ericson ericson@cc.gatech.edu
 *
 * Modified 17 July 2007 Pam Cutter Kalamazoo College
 * 	  Added a copySoundInto method which allows copying as much of
 * 	   this sound as will fit into a destination sound
 *    Added a cropSound method which returns a new sound which is a
 *     specified portion of this sound
 *
 * Kalamazoo and other additional methods merged by Buck Scharfnorth 22 May 2008
 */

/**
 * This class allows you to explore a Sound.  You can see the line drawing
 * of the sound samples and play all or part of a sound.  You can zoom in to see
 * all the samples in the sound or zoom out to see the entire sound.  You
 * can click on the sound wave to see the value at that index.
 * <br>
 * Copyright Georgia Institute of Technology 2004
 * @author Keith McDermottt, gte047w@cc.gatech.edu
 * @author Barb Ericson ericson@cc.gatech.edu
 *
 * Modified 19 July 2007 Pamela Cutter Kalamazoo College
 *   Modified the code so that a sound would display correctly,
 *    using either a 0 or a 1 as the base.  Set the base to
 *    be 1, since that is consistent with how students work with
 *    sounds.
 *
 * Kalamazoo code merged by Buck Scharfnorth 22 May 2008
 */
class SoundExplorer implements MouseMotionListener, ActionListener,
  MouseListener, LineListener
{
  private static final String zoomInHint =
     "Click to see all the samples (the number of samples between pixels is 1)";
  /** set to true for debugging and false for normal */
  private boolean DEBUG = false;

  ///////    main parts of the gui  /////////////////////////////

  /** the main window */
  private JFrame soundFrame;
  /** panel that contains the buttons to play all or part of a sound and show
   * selection information */
  private JPanel playPanel;
  /** scroll pane that holds the sound panel */
  private JScrollPane scrollSound;
  /** The panel that shows the sound wave */
  private JPanel soundPanel;

  //////////   general information  ////////////////////////////
  /** the sound displayed in this window */
  private SimpleSound sound;

  /**
   * Whether to display the sound in stereo - NOT neccessarily
   * whether or not the sound is in stereo
   */
  private boolean inStereo;

  /////////////////// parts of the play panel ////////////////

  /** label that shows the start index for the selection */
  private JLabel startIndexLabel;
  /** label that shows the stop index for the selection */
  private JLabel stopIndexLabel;
  /** panel that holds the play buttons */
  private JPanel buttonPanel;
  /** button to play the entire sound */
  private JButton playEntireButton;
  /** button to play the current selection */
  private JButton playSelectionButton;
  /** button to play the sound before the current index (inclusive) */
  private JButton playBeforeButton;
  /** button to play the sound after the current index (inclusive) */
  private JButton playAfterButton;
  /** button to clear the selection */
  private JButton clearSelectionButton;
  /** button to stop playing the sound */
  private JButton stopButton;

  //info related to the play panel
  private boolean selectionPrevState;


  //////////////// parts of the sound panel /////////////

  /** outer panel for left sound */
  private JPanel leftSoundPanel;
  /** outer panel for right sound (if stereo) */
  private JPanel rightSoundPanel;
  /** panel just used to center the left sample panel */
  private JPanel leftSampleWrapper;
  /** panel just used to center the right sample panel */
  private JPanel rightSampleWrapper;
  /** panel that displays the left sound wave */
  private SamplingPanel leftSamplePanel;
  /** panel that displays the right sound wave */
  private SamplingPanel rightSamplePanel;

  ////////////////  parts of the information panel //////////////

  /** the current index information panel */
  private JPanel infoPanel;
  /** the current index label */
  private JLabel indexLabel;
  /** the number of samples per pixel field */
  private JTextField numSamplesPerPixelField;
  /** text field to display the current index value */
  private JTextField indexValue;
  /** label for the left sample value */
  private JLabel leftSampleLabel;
  /** text field that shows the value for the left sample at the current index */
  private JTextField leftSampleValue;
  /** label for the right sample value */
  private JLabel rightSampleLabel;
  /** text field that shows the value for the right sample at the current index */
  private JTextField rightSampleValue;
  /** panel that holds the zoom button */
  private JPanel zoomButtonPanel;
  /** zoom in and out button */
  private JButton zoomButton;
  /** button to go to the previous index */
  private JButton prevButton;
  /** button to go to the next index */
  private JButton nextButton;
  /** button to go to the last index */
  private JButton lastButton;
  /** button to go to the first index */
  private JButton firstButton;

  //info related to the sound panel
  /** width of the displayed sound in pixels when fully zoomed out */
  private int zoomOutWidth;
  /** width of the displayed sound in pixels when fully zoomed in (framesPerPixel = 1) */
  private int zoomInWidth;
  /** current width of the sound in pixels */
  private int sampleWidth;
  /** current height of the sound in pixels */
  private int sampleHeight;
  //private int labelHeight;
  private int soundPanelHeight;

  /** number of samples (frames) (amount to add to index to get to next pixel) */
  private float framesPerPixel;
  //private int cushion;
  /** current position in pixels */
  private int currentPixelPosition;
  /** start at 0 or 1 base */
  private int base = SimpleSound._SoundIndexOffset;

  //info related to event handling
  private int mousePressed;
  private int mouseReleased;
  private int mousePressedX;
  private int mouseReleasedX;
  private boolean mouseDragged;
  private int startFrame;
  private int stopFrame;
  private int selectionstart;
  private int selectionstop;

  ///CONSTANTS///
  private static final String currentIndexText = "Current Index: ";
  private static final String startIndexText = "Start Index: ";
  private static final String stopIndexText = "Stop Index: ";
  private static final Color selectionColor = Color.gray;
  private static final Color backgroundColor = Color.black;
  private static final Color waveColor = Color.white;
  private static final Color barColor = Color.cyan;

  ///////////////////////// class fields ///////////////////////////
  private static String leftSampleText = "Sample Value: ";
  private static String rightSampleText = "Right (Bottom) Sample Value: ";

  /**
   * Constructor that takes a sound and a boolean flag
   * @param sound the sound to view
   * @param inStereo true if you want to show it in stereo
   */
  public SoundExplorer(SimpleSound sound, boolean inStereo)
  {
    this.sound = sound;
    this.inStereo = inStereo;

    if(inStereo)
      leftSampleText = "Left (Top) Sample Value: ";

    //this causes the Sound class to add this SoundExplorer
    //as the line listener for any SourceDataLines created so
    //we can monitor starting and stopping to enable/disable
    //play and stop buttons
    sound.setSoundExplorer(this);

    //used for determining difference between a mouse release
    //after a click and a mouse release after a drag.  upon dragging,
    //we want to select a region, upon clicking, only move the
    //vertical bar
    mouseDragged = false;
    selectionstart = -1;
    selectionstop = -1;

    //size of the sampling panel
    zoomOutWidth = 640;
    zoomInWidth = sound.getLengthInFrames();
    sampleWidth = zoomOutWidth;
    framesPerPixel = sound.getLengthInFrames() / sampleWidth;
    sampleHeight = 201;
    //labelHeight = 50;

    //cushion so that the sampling panel isn't flush against the
    //left side - we want a small border so it looks neater
    //cushion = 10;

    //the current pixel position
    currentPixelPosition = 0;

    //display everything
    createWindow();
  }

  /**
   * Method to print out exception information
   * @param ex the exception object
   */
  private void catchException(Exception ex)
  {
    System.err.println(ex.getMessage());
  }

  /**
   * Method to set the title on the main window
   * @param s the string to use as the title
   */
  public void setTitle(String s)
  {
    soundFrame.setTitle(s);
  }

  /**
   * Method to create the main window
   */
  private void createWindow()
  {
    String fileName = sound.getFileName();
    if(fileName==null)
      fileName = "no file name";

    soundFrame = new JFrame(fileName);

//    if(inStereo)
//    {
//      soundFrame.
//        setSize(new Dimension
//                  (zoomOutWidth+cushion,
//                   2*(sampleHeight+cushion)+labelHeight+100));
//    }
//    else
//    {
//      soundFrame.
//        setSize(new Dimension
//                  (zoomOutWidth+cushion,
//                   sampleHeight+cushion+labelHeight+100));
//    }
    // get the sound frame content pane and save it
    Container frameContainer = soundFrame.getContentPane();

    frameContainer.setLayout(new BorderLayout());
    soundFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
    //also on close we need to remove the soundView listener?

    //creates the play panel
    createPlayPanel();
    frameContainer.add(playPanel, BorderLayout.NORTH);

    //creates the sound panel
    createSoundPanel();

    //creates the scrollpane for the sound
    scrollSound = new JScrollPane();
    scrollSound.setViewportView(soundPanel);
    frameContainer.add(scrollSound, BorderLayout.CENTER);
    //scrollSound.setVerticalScrollBarPolicy
     // (JScrollPane.VERTICAL_SCROLLBAR_NEVER);
    //scrollSound.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS );

    //creates the info panel - this displays the current index
    //and sample values
    createInfoPanel();

    frameContainer.add(infoPanel, BorderLayout.SOUTH);

    // set the size based on the size of the contents
    soundFrame.pack();
    soundFrame.setResizable(false);
    soundFrame.setVisible(true);


  }//createWindow()

  /**
   * Method to create the button and add it to the passed panel
   * @param name the label for the button
   * @param enabled if true set button enabled else disable it
   * @param panel the panel to add the button to
   */
  private JButton makeButton(String name, boolean enabled, JPanel panel)
  {
    JButton j = new JButton(name);
    j.addActionListener(this);
    j.setEnabled(enabled);
    panel.add(j);
    return j;
  }

  /**
   * Method to clear the selection information
   */
  private void clearSelection()
  {
    selectionstart = -1;
    selectionstop = -1;
    startIndexLabel.setText(startIndexText + "N/A");
    stopIndexLabel.setText(stopIndexText + "N/A");
    soundFrame.getContentPane().repaint();
    playSelectionButton.setEnabled(false);
    clearSelectionButton.setEnabled(false);
  }

  /**
   * Method to create the panel that has the buttons for playing all or
   * part of the sound.  Also shows information about the selection (if one)
   */
  private void createPlayPanel()
  {

    // set up the play panel
    playPanel = new JPanel();
    //playPanel.setPreferredSize(new Dimension(zoomOutWidth, 60));
    playPanel.setLayout(new BorderLayout());

    // create the selection panel items
    JPanel selectionPanel = new JPanel();
    startIndexLabel = new JLabel(startIndexText + "N/A");
    stopIndexLabel = new JLabel(stopIndexText + "N/A");
    playSelectionButton = makeButton("Play Selection", false, selectionPanel);
    clearSelectionButton = makeButton("Clear Selection",false,selectionPanel);
    clearSelectionButton.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        clearSelection();
      }
    });
    selectionPanel.add(startIndexLabel);
    selectionPanel.add(stopIndexLabel);

    // set up the button panel
    buttonPanel = new JPanel();
    playEntireButton = makeButton("Play Entire Sound", true, buttonPanel);
    selectionPrevState = false;
    playBeforeButton = makeButton("Play Before", false, buttonPanel);
    playAfterButton = makeButton("Play After", true, buttonPanel);
    stopButton = makeButton("Stop", false, buttonPanel);

    // add tool tip text
    playBeforeButton.setToolTipText("Play sound up to the current index");
    playAfterButton.setToolTipText("Play sound starting at the current index");
    playEntireButton.setToolTipText("Play the entire sound");
    playSelectionButton.setToolTipText("Play sound between start and stop index");
    stopButton.setToolTipText("Stop playing the sound");
    clearSelectionButton.setToolTipText("Click to clear (remove) the selection");

    // add the button panel and selection panel to the play panel
    playPanel.add(buttonPanel, BorderLayout.NORTH);
    playPanel.add(selectionPanel,BorderLayout.SOUTH);

  }//createPlayPanel()

  /**
   * Method to create the panel for displaying the sound wave(s)
   */
  private void createSoundPanel()
  {
    //the main panel, we'll add everything to this at the end
    soundPanel = new JPanel();
    if(inStereo)
      soundPanel.setLayout(new GridLayout(2,1));
    else
      soundPanel.setLayout(new GridLayout(1,1));

    /*
     do all the stuff to display the left channel.  we'll only
     make the stuff to display the right channel if neccessary.
     everything will go into the leftSoundPanel, which is then
     added to the main soundPanel
     */
    leftSoundPanel = new JPanel();
    leftSoundPanel.setLayout(new BorderLayout());
    leftSoundPanel.setPreferredSize
      //(new Dimension(sampleWidth, sampleHeight+cushion));
      (new Dimension(sampleWidth, sampleHeight));

    /*
     the sampling panel - this is where the wave form displays.
     we put it in a wrapper so that it looks centered within the
     main soundPanel
     */
    leftSampleWrapper = new JPanel();//so its centered
    leftSamplePanel = new SamplingPanel(true);
    leftSamplePanel.addMouseMotionListener(this);
    leftSamplePanel.addMouseListener(this);
    leftSampleWrapper.add(leftSamplePanel);
    leftSampleWrapper.
      //setPreferredSize(new Dimension(sampleWidth, sampleHeight+ cushion));
      setPreferredSize(new Dimension(sampleWidth, sampleHeight));

    /*
     put all the pieces into the left sound panel:
     the sample at the top, below it we want the
     current index on the left
     zoom button in the middle (unless its stereo - then the zoom button
     goes in the right sound panel)
     and current sample value on the right
     */
    leftSoundPanel.add(leftSampleWrapper, BorderLayout.NORTH);

    soundPanel.add(leftSoundPanel);

    //soundPanelHeight = sampleHeight+cushion;
    soundPanelHeight = sampleHeight;

    if(inStereo)
    {
      rightSoundPanel = new JPanel();
      rightSoundPanel.setLayout(new BorderLayout());
      rightSoundPanel.setPreferredSize
        //(new Dimension(sampleWidth, sampleHeight+cushion));
      (new Dimension(sampleWidth, sampleHeight));

      rightSampleWrapper = new JPanel();
      rightSamplePanel = new SamplingPanel(false);
      rightSamplePanel.addMouseMotionListener(this);
      rightSamplePanel.addMouseListener(this);
      rightSampleWrapper.add(rightSamplePanel);
      rightSampleWrapper.setPreferredSize
        //(new Dimension(sampleWidth, sampleHeight+cushion));
        (new Dimension(sampleWidth, sampleHeight));


      rightSoundPanel.add(rightSampleWrapper, BorderLayout.NORTH);

      soundPanel.add(rightSoundPanel);

      //soundPanelHeight = 2*(sampleHeight+cushion);
      soundPanelHeight = 2*(sampleHeight);
    }

    soundPanel.setPreferredSize(new Dimension(zoomOutWidth,soundPanelHeight));
    soundPanel.setSize(soundPanel.getPreferredSize());
  }

  /**
   * Method to update the index values to the current index position
   */
  private void updateIndexValues()
  {
    // calculate the current sample (frame) index
    int curFrame = (int)(currentPixelPosition * framesPerPixel)+base;

    // update the display of the current sample (frame) index
    indexValue.setText(Integer.toString(curFrame));

    // update the number of samples per (between) pixels field
    if (numSamplesPerPixelField != null)
      numSamplesPerPixelField.setText(Integer.toString((int) framesPerPixel));

    // try to update the value(s) at the current sample index
    try
    {
      leftSampleValue.setText(Integer.toString(sound.getLeftSample(curFrame-base)));
      if(inStereo)
        rightSampleValue.setText(Integer.toString(sound.getRightSample(curFrame-base)));
    }
    catch(Exception ex)
    {
      catchException(ex);
    }
  }

  /**
   * Method to set up the index panel.  This panel has buttons for going to
   * the first index, previous index, the current index label, the current index
   * value or values (if in stereo), next index button, and a last index button
   * @param indexPanel the panel to set-up
   */
  private void setUpIndexPanel(JPanel indexPanel)
  {
    JPanel topPanel = new JPanel();
    Box vertBox = Box.createVerticalBox();

     // create the image icons for the buttons
    Icon prevIcon = new ImageIcon(SoundExplorer.class.getResource("leftArrow.gif"),
                                  "previous index");
    Icon nextIcon = new ImageIcon(SoundExplorer.class.getResource("rightArrow.gif"),
                                  "next index");
    Icon firstIcon = new ImageIcon(SoundExplorer.class.getResource("endLeft.gif"),
                                   "first index");
    Icon lastIcon = new ImageIcon(SoundExplorer.class.getResource("endRight.gif"),
                                  "last index");

    // create the arrow buttons
    prevButton = new JButton(prevIcon);
    firstButton = new JButton(firstIcon);
    nextButton = new JButton(nextIcon);
    lastButton = new JButton(lastIcon);

    // set the tool tip text
    prevButton.setToolTipText("Click to view previous index (sample at previous pixel)");
    firstButton.setToolTipText("Click to view first index (sample at first pixel)");
    nextButton.setToolTipText("Click to view next index (sample at next pixel)");
    lastButton.setToolTipText("Click to view last index (sample at last pixel)");

    // set the preferred sizes of the buttons
    prevButton.setPreferredSize(new Dimension(prevIcon.getIconWidth() + 2,
                                              prevIcon.getIconHeight() + 2));
    firstButton.setPreferredSize(new Dimension(firstIcon.getIconWidth() + 2,
                                               firstIcon.getIconHeight() + 2));
    nextButton.setPreferredSize(new Dimension(nextIcon.getIconWidth() + 2,
                                              nextIcon.getIconHeight() + 2));
    lastButton.setPreferredSize(new Dimension(lastIcon.getIconWidth() + 2,
                                               lastIcon.getIconHeight() + 2));


    // handle previous button press
    prevButton.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent evt) {
        currentPixelPosition--;
        if (currentPixelPosition < 0)
          currentPixelPosition = 0;
        updateIndexValues();
        checkScroll();
        soundFrame.getContentPane().repaint();
      }
    });

    // handle next button press
    nextButton.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent evt) {
        currentPixelPosition++;
        if (currentPixelPosition * framesPerPixel >= sound.getNumSamples())
          currentPixelPosition = (int) ((sound.getNumSamples() - 1) / framesPerPixel);
        updateIndexValues();
        checkScroll();
        soundFrame.getContentPane().repaint();
      }
    });

    // handle first button press
    firstButton.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent evt) {
        currentPixelPosition = 0;
        updateIndexValues();
        checkScroll();
        soundFrame.getContentPane().repaint();
      }
    });

    // handle last button press
    lastButton.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent evt) {
        currentPixelPosition = (int) ((sound.getNumSamples() - 1) / framesPerPixel);
        updateIndexValues();
        checkScroll();
        soundFrame.getContentPane().repaint();
      }
    });

    // create the index value textfield
    indexValue = new JTextField(Integer.toString(base),8);
    indexValue.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {

        // zoom in around user entered value
        handleZoomIn(Integer.parseInt(indexValue.getText()));

        // update the values for the pixel at the current index
        updateIndexValues();
      }
    });

    // create the left sample value and right sample value textfields
    leftSampleValue = new JTextField(8);
    leftSampleValue.setEditable(false);
    rightSampleValue = new JTextField(8);
    rightSampleValue.setEditable(false);

    // create the labels
    indexLabel = new JLabel(currentIndexText);
    leftSampleLabel = new JLabel(leftSampleText);
    rightSampleLabel = new JLabel(rightSampleText);
    updateIndexValues();

    // add the buttons and label to the top panel
    topPanel.add(firstButton);
    topPanel.add(prevButton);
    topPanel.add(indexLabel);
    topPanel.add(indexValue);
    topPanel.add(leftSampleLabel);
    topPanel.add(leftSampleValue);
    if (inStereo) {
      topPanel.add(rightSampleLabel);
      topPanel.add(rightSampleValue);
    }
    topPanel.add(nextButton);
    topPanel.add(lastButton);

    // create bottom panel
    JPanel bottomPanel = new JPanel();
    bottomPanel.add(new JLabel("The number of samples between pixels: "));
    numSamplesPerPixelField = new JTextField(Integer.toString((int) framesPerPixel),8);
    numSamplesPerPixelField.setToolTipText("Click here to zoom in (decrease) or out (increase))");
    numSamplesPerPixelField.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {

        // zoom in around user entered value
        handleFramesPerPixel(Integer.parseInt(numSamplesPerPixelField.getText()));

        // update the values for the pixel at the current index
        updateIndexValues();
      }
    });
    bottomPanel.add(numSamplesPerPixelField);


    // add the top panel to the box
    vertBox.add(topPanel);
    vertBox.add(bottomPanel);

    // add the vertical box to the index panel
    indexPanel.add(vertBox);

  }

  /**
   * Method to create the information panel which holds the index information, the value
   * for the current index, and the zoom button
   */
  private void createInfoPanel()
  {
    // create the information panel and set the layout
    infoPanel = new JPanel();
    infoPanel.setLayout(new BorderLayout());

    // create the index panel and set it up
    JPanel indexPanel = new JPanel();
    indexPanel.setLayout(new FlowLayout());
    setUpIndexPanel(indexPanel);

    // create a zoom panel with a zoom button
    zoomButtonPanel = new JPanel();
    zoomButton = makeButton("Zoom In", true, zoomButtonPanel);
    zoomButton.setToolTipText(zoomInHint);

    infoPanel.add(BorderLayout.NORTH,indexPanel);
    infoPanel.add(BorderLayout.SOUTH,zoomButtonPanel);

  }

  /**
   * Handle a mouse click event
   * @param e the mouse event
   */
  public void mouseClicked(MouseEvent e)
  {
    currentPixelPosition = e.getX();

    if(currentPixelPosition==0)
    {
      playBeforeButton.setEnabled(false);
      playAfterButton.setEnabled(true);
    }
    else if(currentPixelPosition < sampleWidth)
    {
      playBeforeButton.setEnabled(true);
      playAfterButton.setEnabled(true);
    }
    else if(currentPixelPosition == sampleWidth)
    {
      playBeforeButton.setEnabled(true);
      playAfterButton.setEnabled(false);
    }

    if(DEBUG)
      System.out.println("mouse click:  " + currentPixelPosition);

    updateIndexValues();
    soundPanel.repaint();
  }

  /**
   * Method to handle a mouse press
   * @param e the mouse event
   */
  public void mousePressed(MouseEvent e)
  {
    mousePressedX = e.getX();
  }

  /**
   * Method to handle a mouse release
   * @param e the mouse event
   */
  public void mouseReleased(MouseEvent e)
  {
    mouseReleasedX = e.getX();

    if(mouseDragged)
    {

      mousePressed = mousePressedX;
      mouseReleased = mouseReleasedX;

      if (mousePressed > mouseReleased)//selected right to left
      {
        int temp = mousePressed;
        mousePressed = mouseReleased;
        mouseReleased = temp;
      }

      startFrame = (int)(mousePressed * framesPerPixel);
      stopFrame = (int)(mouseReleased * framesPerPixel);

      //stopped dragging outside the window.
      if(stopFrame >= sound.getLengthInFrames())
        stopFrame = sound.getLengthInFrames();

      //stopped dragging outside the window
      if(startFrame < 0)
        startFrame = 0;

      //new values for the labels
      startIndexLabel.setText(startIndexText + (startFrame));
      stopIndexLabel.setText(stopIndexText + (stopFrame));

      //for highlighting the selection
      selectionstart = mousePressed;
      selectionstop = mouseReleased;

      soundPanel.repaint();
      playSelectionButton.setEnabled(true);
      clearSelectionButton.setEnabled(true);
      mouseDragged = false;
    }

  }

  /**
   * Method to handle a mouse entered event
   * @param e the mouse event
   */
  public void mouseEntered(MouseEvent e)
  {}

  /**
   * Method to handle a mouse exited event
   * @param e the mouse event
   */
  public void mouseExited(MouseEvent e)
  {}

  /**
   * Method to handle a mouse dragged event
   * @param e the mouse event
   */
  public void mouseDragged(MouseEvent e)
  {
    mouseDragged = true;

    //highlight the selection as we drag by pretending
    //that we're releasing the mouse at each point
    mouseReleased(e);
  }

  /**
   * Method to handle a mouse move event
   * @param e the mouse event
   */
  public void mouseMoved(MouseEvent e)
  {}

  /**
   * Method to handle the line event update
   * @param e the line event
   */
  public void update(LineEvent e)
  {
    if(e.getType().equals(LineEvent.Type.OPEN))
    {
      playEntireButton.setEnabled(false);
      playBeforeButton.setEnabled(false);
      playAfterButton.setEnabled(false);
      selectionPrevState = playSelectionButton.isEnabled();
      playSelectionButton.setEnabled(false);
      clearSelectionButton.setEnabled(false);
      stopButton.setEnabled(true);
    }
    if(e.getType().equals(LineEvent.Type.CLOSE))
    {
      playEntireButton.setEnabled(true);
      playSelectionButton.setEnabled(selectionPrevState);
      clearSelectionButton.setEnabled(selectionPrevState);
      stopButton.setEnabled(false);
      if(currentPixelPosition==0)
      {
        playBeforeButton.setEnabled(false);
        playAfterButton.setEnabled(true);
      }
      else if(currentPixelPosition < sampleWidth)
      {
        playBeforeButton.setEnabled(true);
        playAfterButton.setEnabled(true);
      }
      else if(currentPixelPosition == sampleWidth)
      {
        playBeforeButton.setEnabled(true);
        playAfterButton.setEnabled(false);
      }
    }

  }

  /**
   * Method to handle an action event
   * @param e the action event
   */
  public void actionPerformed(ActionEvent e)
  {
    if(e.getActionCommand() == "Play Entire Sound")
    {
      try
      {
        sound.play();
      }
      catch(Exception ex)
      {
        catchException(ex);
      }
    }
    else if(e.getActionCommand() == "Play Selection")
    {
      try
      {
        sound.playAtRateInRange(1, startFrame, stopFrame);
      }
      catch(Exception ex)
      {
        catchException(ex);
      }
    }
    else if(e.getActionCommand().equals("Stop"))
    {
      //stop all playback threads related to this sound
      for(int i = 0; i < sound.getPlaybacks().size(); i++)
      {
        ((Playback)sound.getPlaybacks().elementAt(i))
          .stopPlaying();
      }
    }
    else if(e.getActionCommand().equals("Zoom In"))
    {
      handleZoomIn(true);
    }
    else if (e.getActionCommand().equals("Zoom Out"))
    {
      handleZoomOut();
    }
    else if(e.getActionCommand().equals("Play Before"))
    {
      try
      {
        sound.playAtRateInRange
          (1, 0, (int)(currentPixelPosition * framesPerPixel));
      }
      catch(Exception ex)
      {
        catchException(ex);
      }
    }
    else if(e.getActionCommand().equals("Play After"))
    {
      try
      {
        sound.playAtRateInRange
          (1, (int)(currentPixelPosition*framesPerPixel),
           sound.getLengthInFrames()-1);
      }
      catch(Exception ex)
      {
        catchException(ex);
      }
    }
    else
    {
     // System.err.println("command not defined: " +
     //                    e.getActionCommand());
    }

  }

  /**
   * Method to check that the current position is in the viewing area and if
   * not scroll to center the current position if possible
   */
  public void checkScroll()
  {
    // only do this if we are not zoomed out
    if (sampleWidth != zoomOutWidth) {

      // get the rectangle that defines the current view
      JViewport viewport = scrollSound.getViewport();
      Rectangle rect = viewport.getViewRect();
      int rectMinX = (int) rect.getX();
      int rectWidth = (int) rect.getWidth();
      int rectMaxX = rectMinX + rectWidth - 1;

      // get the maximum possible index
      int maxIndex = sound.getLength() - rectWidth - 1;

      // check if current position is outside viewing area
      if (currentPixelPosition < rectMinX ||
          currentPixelPosition > rectMaxX) {

        // calculate how to position the current position in the middle of the viewing
        // area
        int barXPos = currentPixelPosition - (int) (rectWidth / 2);
        int barYPos = (int) (sampleHeight - rect.getHeight()) / 2;

        // check if the barPos is less than 0 or greater than max
        if (barXPos < 0)
          barXPos = 0;
        else if (barXPos > maxIndex)
          barXPos = maxIndex;

        // move the viewport upper left point
        viewport.setViewPosition(new Point(barXPos, barYPos));
      }
    }
  }

  /**
   * Method to handle a zoom in
   */
  private void handleZoomIn(boolean checkScrollFlag)
  {
    // change the zoom button to zoom out information
    zoomButton.setText("Zoom Out");
    zoomButton.setToolTipText("Click to zoom out (see the whole sound)");

    // get the frame index current position, selection start and stop
    currentPixelPosition = (int)(currentPixelPosition*framesPerPixel);
    selectionstart = (int)(selectionstart*framesPerPixel);
    selectionstop = (int)(selectionstop*framesPerPixel);

    if(DEBUG)
      System.out.println("Zoom In:  currentPixelPosition = " +
                         currentPixelPosition);

    sampleWidth = zoomInWidth;
    framesPerPixel = sound.getLengthInFrames() / sampleWidth;

    soundPanel.setPreferredSize(new Dimension(zoomInWidth,
                                              soundPanel.getHeight()));
    soundPanel.setSize(soundPanel.getPreferredSize());

    leftSoundPanel.setPreferredSize(new Dimension(zoomInWidth,
                                                  leftSoundPanel.getHeight()));
    leftSoundPanel.setSize(leftSoundPanel.getPreferredSize());

    leftSampleWrapper.setPreferredSize(new Dimension(zoomInWidth,
                                                     leftSampleWrapper.getHeight()));
    leftSampleWrapper.setSize(leftSampleWrapper.getPreferredSize());
    leftSamplePanel.setPreferredSize(new Dimension(sampleWidth,
                                                   sampleHeight));
    leftSamplePanel.setSize(leftSamplePanel.getPreferredSize());

    leftSamplePanel.createWaveForm(true);

    if(inStereo)
    {
      rightSoundPanel.setPreferredSize
        (new Dimension(zoomInWidth,
                       rightSoundPanel.getHeight()));
      rightSoundPanel.setSize
        (rightSoundPanel.getPreferredSize());

      rightSampleWrapper.setPreferredSize
        (new Dimension(zoomInWidth,
                       rightSampleWrapper.getHeight()));
      rightSampleWrapper.setSize
        (rightSampleWrapper.getPreferredSize());

      rightSamplePanel.setPreferredSize
        (new Dimension(zoomInWidth,
                       rightSamplePanel.getHeight()));
      rightSamplePanel.setSize
        (rightSamplePanel.getPreferredSize());

      rightSamplePanel.createWaveForm(false);
    }
    if(DEBUG)
    {
      System.out.println("ZOOM IN SIZES:");
      System.out.println("\tleftSamplePanel: " +
                         leftSamplePanel.getSize());
      System.out.println("\t\tpreferred: " +
                         leftSamplePanel.getPreferredSize());

      System.out.println("\tleftSampleWrapper: " +
                         leftSampleWrapper.getSize());
      System.out.println("\t\tpreferred: " +
                         leftSampleWrapper.getPreferredSize());

      System.out.println("\tleftSoundPanel: " +
                         leftSoundPanel.getSize());
      System.out.println("\t\tpreferred: " +
                         leftSoundPanel.getPreferredSize());

      System.out.println("\tsoundPanel: " +
                         soundPanel.getSize());
      System.out.println("\t\tpreferred: " +
                         soundPanel.getPreferredSize());
    }

    // revalidate to handle the new preferred sizes
    scrollSound.revalidate();

    // update the index values
    updateIndexValues();

    // check for the need to scroll
    if (checkScrollFlag)
       checkScroll();
  }

  /**
   * Method to handle a zoom in to view all sample values
   * @param index the index to use after the zoom in
   */
  private void handleZoomIn(int index)
  {
    if (index % framesPerPixel != 0) {
       // do normal zoom in on current position
       handleZoomIn(false);
    }

    // change current position to the passed index
    currentPixelPosition = (int) (index / framesPerPixel)-base;

    // now check the scroll
    checkScroll();

    // repaint
    soundPanel.repaint();

  }

  /**
   * Method to handle a zoom out to view the entire sound wave
   */
  private void handleZoomOut()
  {
    zoomButton.setText("Zoom In");
    zoomButton.setToolTipText(zoomInHint);

    sampleWidth = zoomOutWidth;
    framesPerPixel = sound.getLengthInFrames() / sampleWidth;

    int divisor = (sound.getLengthInFrames()/sampleWidth);
    currentPixelPosition = (int)(currentPixelPosition/divisor);
    selectionstart = (int)(selectionstart/divisor);
    selectionstop = (int)(selectionstop/divisor);

    if(DEBUG)
      System.out.println("Zoom Out:  currentPixelPosition = " +
                         currentPixelPosition);

    soundPanel.setPreferredSize
      (new Dimension(zoomOutWidth,
                     soundPanel.getHeight()));
    soundPanel.setSize(soundPanel.getPreferredSize());

    leftSoundPanel.setPreferredSize
      (new Dimension(zoomOutWidth,
                     leftSoundPanel.getHeight()));
    leftSoundPanel.setSize(leftSoundPanel.getPreferredSize());

    leftSampleWrapper.setPreferredSize
      (new Dimension(zoomOutWidth,
                     leftSampleWrapper.getHeight()));
    leftSampleWrapper.setSize
      (leftSampleWrapper.getPreferredSize());

    leftSamplePanel.setPreferredSize
      (new Dimension(sampleWidth, sampleHeight));
    leftSamplePanel.setSize(leftSamplePanel.getPreferredSize());

    leftSamplePanel.createWaveForm(true);

    if(inStereo)
    {
      rightSoundPanel.
        setPreferredSize
        (new Dimension(zoomOutWidth,
                       rightSoundPanel.getHeight()));
      rightSoundPanel.setSize
        (rightSoundPanel.getPreferredSize());

      rightSampleWrapper.setPreferredSize
        (new Dimension(zoomOutWidth,
                       rightSampleWrapper.getHeight()));
      rightSampleWrapper.setSize
        (rightSampleWrapper.getPreferredSize());

      rightSamplePanel.setPreferredSize
        (new Dimension(sampleWidth, sampleHeight));
      rightSamplePanel.setSize
        (rightSamplePanel.getPreferredSize());

      rightSamplePanel.createWaveForm(false);
    }

    updateIndexValues();

    soundPanel.repaint();
  }

  /**
   * Method to handle an entry of the desired number of frames (samples)
   * shown per pixel
   * @param numFrames (the number of samples shown in a pixel)
   */
  private void handleFramesPerPixel(int numFrames)
  {

    // get the current index from the pixel position and frames per pixel
    int currIndex = (int) (currentPixelPosition * framesPerPixel);
    sampleWidth = sound.getLengthInFrames() / numFrames;
    framesPerPixel = numFrames;

    int divisor = (sound.getLengthInFrames()/sampleWidth);
    currentPixelPosition = (int)(currIndex/divisor); // new curr pixel
    selectionstart = (int)(selectionstart/divisor);
    selectionstop = (int)(selectionstop/divisor);

    soundPanel.setPreferredSize
      (new Dimension(sampleWidth,
                     soundPanel.getHeight()));
    soundPanel.setSize(soundPanel.getPreferredSize());

    leftSoundPanel.setPreferredSize
      (new Dimension(sampleWidth,
                     leftSoundPanel.getHeight()));
    leftSoundPanel.setSize(leftSoundPanel.getPreferredSize());

    leftSampleWrapper.setPreferredSize
      (new Dimension(sampleWidth,
                     leftSampleWrapper.getHeight()));
    leftSampleWrapper.setSize
      (leftSampleWrapper.getPreferredSize());

    leftSamplePanel.setPreferredSize
      (new Dimension(sampleWidth, sampleHeight));
    leftSamplePanel.setSize(leftSamplePanel.getPreferredSize());

    leftSamplePanel.createWaveForm(true);

    if(inStereo)
    {
      rightSoundPanel.
        setPreferredSize
        (new Dimension(sampleWidth,
                       rightSoundPanel.getHeight()));
      rightSoundPanel.setSize
        (rightSoundPanel.getPreferredSize());

      rightSampleWrapper.setPreferredSize
        (new Dimension(sampleWidth,
                       rightSampleWrapper.getHeight()));
      rightSampleWrapper.setSize
        (rightSampleWrapper.getPreferredSize());

      rightSamplePanel.setPreferredSize
        (new Dimension(sampleWidth, sampleHeight));
      rightSamplePanel.setSize
        (rightSamplePanel.getPreferredSize());

      rightSamplePanel.createWaveForm(false);
    }

    // revalidate to handle the new preferred sizes
    scrollSound.revalidate();

    // update the index values
    updateIndexValues();

    // check for the need to scroll
    checkScroll();

    soundPanel.repaint();
  }

  /**
   * Method to set the base for the index.  The default is a base of 0.
   * @param base the new base to use (for example use setBase(1))
   * to use base 1 instead of 0
   */
  public void setBase(int base)
  {
    this.base = base;
  }

  /**
   * Class to display the sound wave
   */
  private class SamplingPanel extends JPanel
  {

    private boolean forLeftSample;
    private Vector<Point2D.Float> points;
    private static final long serialVersionUID = 7526471155622776147L;

    /**
     * Constructor that takes a flag to tell if for left or right sample
     * @param inputForLeftSample if true = left if false = right
     */
    public SamplingPanel(boolean inputForLeftSample)
    {
      forLeftSample = inputForLeftSample;

      if(DEBUG)
        System.out.println("creating new sampling panel: " +
                           "\n\tfor left sample: "+forLeftSample +
                           "\n\tsampleWidth: " + sampleWidth +
                           "\n\tsampleHeight: " + sampleHeight);

      setBackground(backgroundColor);
      setPreferredSize(new Dimension(sampleWidth, sampleHeight));
      setSize(getPreferredSize());
      if(DEBUG)
        System.out.println("\tSample panel preferred size: " +
                           getPreferredSize() + "\n\tSample panel size: " + getSize());

      points = new Vector<Point2D.Float>();
      createWaveForm(forLeftSample);
    }//constructor(forLeftSample)

    /**
     * Method to create the sound wave
     * @param forLeftSample if true create the left form, if false the right
     */
    public void createWaveForm(boolean forLeftSample)
    {

      //get the max y value for a sound of this sample size
      AudioFormat format = sound.getAudioFileFormat().getFormat();
      float maxValue;

      if(format.getSampleSizeInBits() == 8)
      {
        maxValue = (float)Math.pow(2,7);
      }
      else if(format.getSampleSizeInBits() == 16)
      {
        maxValue = (float)Math.pow(2, 15);
      }
      else if(format.getSampleSizeInBits() == 24)
      {
        maxValue = (float)Math.pow(2, 23);
      }
      else if(format.getSampleSizeInBits() == 32)
      {
        maxValue = (float)Math.pow(2, 31);
      }
      else
      {
        try
        {
          sound.printError("InvalidSampleSize");
        }
        catch(Exception ex)
        {
          catchException(ex);
        }
        return;
      }

      points.clear();
      //framesPerPixel = sound.getLengthInFrames() / sampleWidth;
      for(int pixel = 0; pixel<sampleWidth; pixel++)
      {
        float y;
        float sampleValue;


        if(forLeftSample)
        {
          try
          {
            sampleValue = sound.
              getLeftSample((int)(pixel*framesPerPixel));
          }
          catch(Exception ex)
          {
            catchException(ex);
            return;
          }
        }
        else
        {
          try
          {
            sampleValue = sound.
              getRightSample((int)(pixel*framesPerPixel));
          }
          catch(Exception ex)
          {
            catchException(ex);
            return;
          }
        }

        y = ((float)Math.floor(sampleHeight/2) -
             (sampleValue  * ((float)Math.floor(sampleHeight/2) /
                              maxValue)));

        points.add(new Point2D.Float(pixel, y));
      }//for - collecting points

      if(DEBUG)
        System.out.println("number of points: " + points.size());
      repaint();

    }//createWaveForm()


    /**
     * Method to draw the Sampling Panel
     * @param g the graphics context
     */
    public void paintComponent(Graphics g)
    {
      Rectangle rectToPaint = g.getClipBounds();

      if(DEBUG)
      {
        System.out.println("Repainting: " + rectToPaint);
        System.out.println("\tSampleWidth: " + sampleWidth);
        System.out.println("\tframesPerPixel: " + framesPerPixel);
        System.out.println("\tSample panel size: " + getSize());
        System.out.println("\tSamplePanel Width: " + getWidth());
        System.out.println("\tSamplePanel Height: " + getHeight());
      }

      //clear out the image
      Graphics2D g2 = (Graphics2D)g;
      g2.setBackground(backgroundColor);
      g2.clearRect((int)rectToPaint.getX(), (int)rectToPaint.getY(),
                   (int)rectToPaint.getWidth(), (int)rectToPaint.getHeight());

      //draw the selection if it exists
      if(selectionstart!=-1 && selectionstop!=-1)
      {
        g2.setBackground(selectionColor);
        g2.clearRect(selectionstart, 0,
                     selectionstop-selectionstart+1, sampleHeight);
      }

      //draw the lines
      g2.setColor(waveColor);
      for(int i = (int)rectToPaint.getX();
          i < (rectToPaint.getX() + rectToPaint.getWidth() -1); i++)
      {
        g2.draw(new
                  Line2D.Float((Point2D.Float)points.elementAt(i),
                               (Point2D.Float)points.elementAt(i+1)));
      }

      //draw the center line
      g2.setColor(barColor);
      g2.setStroke(new BasicStroke(1));
      g2.draw(new Line2D.Double(rectToPaint.getX(),
                                Math.floor(sampleHeight/2),
                                rectToPaint.getX()+rectToPaint.getWidth()-1,
                                Math.floor(sampleHeight/2)));

      //draw the current position
      if (rectToPaint.getX()<currentPixelPosition &&
          currentPixelPosition<(rectToPaint.getX()+rectToPaint.getWidth()-1))
      {
        g2.setColor(barColor);
        g2.setStroke(new BasicStroke(1));
        g2.draw(new Line2D.Double(currentPixelPosition, 0,
                                  currentPixelPosition, sampleHeight));
      }
    }//paint(g)

  }//public class SamplingPanel

  /*
  public static void main(String args[])
  {
    try{
      /*
       Sound s = new Sound("/Users/ellie/mediacomp/ellie/really_long_sound.wav");
       SoundExplorer test = new SoundExplorer(s, s.isStereo());
       */


      //Sound s2 = new Sound("/Users/ellie/mediacomp/ellie/SoundDemo/audio/22-new.aif");

      //  SoundExplorer teststereo = new SoundExplorer(s2, true);
      //SoundExplorer testmono = new SoundExplorer(s2, false);

      /*

      Sound windowsSound = new Sound("/Users/ellie/Desktop/sound2.wav");
      SoundExplorer testWin = new SoundExplorer(windowsSound, false);

      Sound shaggz =
        new Sound("/Users/ellie/Desktop/audio2/SOUND1.WAV");
      System.out.println(shaggz.getAudioFileFormat().getFormat());

      shaggz.blockingPlay();

      SoundExplorer shaggzView = new SoundExplorer(shaggz, false);

      Sound shaggz2 =
        new Sound("/Users/ellie/Desktop/audio2/SOUND1.WAV");
      for(int i = 0; i < shaggz2.getLengthInFrames(); i++)
      {
        shaggz2.setSampleValue(i, shaggz2.getSampleValue(i));
      }
      SoundExplorer shaggzView2 = new SoundExplorer(shaggz2, false);

      /*
       Sound emptySound = new Sound(5);
       SoundExplorer testempty = new SoundExplorer(emptySound, false);
       */
      /*
       Sound sStates = new Sound("Z:\\croak.wav");
       SoundExplorer testStates = new SoundExplorer(sStates, sStates.isStereo());
       */
   /* }
    catch(Exception ex)
    {
      System.out.println(ex.getMessage());
    }

  } */
}//end class SoundExplorer
/**
 * Class to display an image and the current location with a + sign
 * <br>
 * Copyright Georgia Institute of Technology 2004
 * @author Barb Ericson ericson@cc.gatech.edu
 */
class ImageDisplay extends JPanel implements Scrollable
{

  /////////////////////////// fields (attributes ///////////////////////////
  private Image image;         // the image to draw
  private Dimension prefSize;  // the preferred size of the display
  private int currentX = 0;    // the current x index
  private int currentY = 0;    // the current y index

  private static final long serialVersionUID = 7526471155622776147L;

  //////////////////////////// constructors /////////////////////////////////

  /**
   * Constructor that takes the image to display
   * @param theImage the image to display
   */
  public ImageDisplay(Image theImage)
  {
    image = theImage;
    prefSize = new Dimension(image.getWidth(this),image.getHeight(this));
    setPreferredSize(prefSize);
    revalidate();
  }

  /**
   * Constructor that takes the image and current x and y
   * @param theImage the image to display
   * @param x the current x value to use
   * @param y the current y value to use
   */
  public ImageDisplay(Image theImage, int x, int y)
  {
    this(theImage);
    currentX = x;
    currentY = y;
  }

  ////////////////////// methods /////////////////////////////////////////////

  /**
   * Method to get the image
   * @return the image
   */
  public Image getImage() { return image; }

  /**
   * Method to get the current x
   * @return the current x value
   */
  public int getCurrentX() { return currentX; }

  /**
   * Method to get the current y
   * @return the current y value
   */
  public int getCurrentY() { return currentY; }

  /**
   * Method to set the current x
   * @param x the x value to use
   */
  public void setCurrentX(int x)
  {
    currentX = x;
    repaint();
  }

  /**
   * Method to set the current y
   * @param y the y value to use
   */
  public void setCurrentY(int y)
  {
    currentY = y;
    repaint();
  }

  /**
   * Method to set the image
   * @param theImage the new image to use
   */
  public void setImage(Image theImage)
  {
    image = theImage;
    setPreferredSize(new Dimension(image.getWidth(this),image.getHeight(this)));
    repaint();
  }

  /**
   * Method to return the preferred size
   * @return the preferred size of this component
   */
  public Dimension getPreferredScrollableViewportSize()
  {
    return prefSize;
  }

  /**
   * Method to return the unit increment for scrolling
   * @param visibleRect the visible rectangle
   * @param orientation vertical or horizontal
   * @param direction neg is up or left and pos is right or down
   * @return the unit increment for arrow clicks
   */
  public int getScrollableUnitIncrement(Rectangle visibleRect,
                                        int orientation,
                                        int direction)
  { return 1; }

  /**
   * Method to return the block increment for scrolling
   * @param visibleRect the visible rectangle
   * @param orientation vertical or horizontal
   * @param direction neg is up or left and pos is right or down
   * @return the block increment for clicking in scroll area
   */
  public int getScrollableBlockIncrement(Rectangle visibleRect,
                                        int orientation,
                                        int direction)
  {
    return 10;
  }

  /**
   * Method to check if the viewport width is the source width
   * @return true if viewport and source have same width
   */
  public boolean getScrollableTracksViewportWidth()
  { return false; }

  /**
   * Method to check if the viewport height is the source height
   * @return true if viewport and soure have same height
   */
  public boolean getScrollableTracksViewportHeight()
  { return false; }

  /**
   * Method to handle displaying this object
   * @param g the graphics object for drawing with
   */
  public void paintComponent(Graphics g)
  {
    super.paintComponent(g);
    int num = 3;
    int xStart = currentX - num;
    int xEnd = currentX + num;
    int yStart = currentY - num;
    int yEnd = currentY + num;
    int width = image.getWidth(this);
    int maxX = width - 1;
    int height = image.getHeight(this);
    int maxY = height - 1;

    // draw the image
    g.drawImage(image,0,0,this);

    // check if the current index is in the image
    if (currentX >= 0 && currentX < width &&
        currentY >= 0 && currentY < height)
    {

      // check that the start and end values are visible
      if (xStart < 0)
        xStart = 0;
      if (xEnd > maxX)
        xEnd = maxX;
      if (yStart < 0)
        yStart = 0;
      if (yEnd > maxY)
        yEnd = maxY;

      // draw a small cross at the current x and y in yellow
      g.setColor(Color.yellow);
      g.drawLine(xStart,currentY,xEnd,currentY);
      g.drawLine(currentX,yStart,currentX,yEnd);
      g.setColor(Color.black);

      // outline the cross in black so that it shows up better
      int leftX = currentX - 1;
      int rightX = currentX + 1;
      int upY = currentY - 1;
      int downY = currentY + 1;
      if (xStart <= leftX && upY >= 0)
        g.drawLine(xStart,upY,leftX,upY);
      if (yStart <= upY && leftX >= 0)
        g.drawLine(leftX,yStart,leftX,upY);
      if (yStart <= upY && rightX <= maxX)
        g.drawLine(rightX,yStart,rightX,upY);
      if (upY >= 0 && rightX <= xEnd)
        g.drawLine(rightX,upY,xEnd,upY);
      if (downY < height && rightX <= xEnd)
        g.drawLine(rightX,downY,xEnd,downY);
      if (downY <= yEnd && rightX < width)
        g.drawLine(rightX,downY,rightX,yEnd);
      if (xStart <= leftX && downY < height)
        g.drawLine(xStart,downY,leftX,downY);
      if (leftX >= 0 && downY <= yEnd)
        g.drawLine(leftX,downY,leftX,yEnd);

    }
  }


}

/**
 * Displays a picture and lets you explore the picture by displaying the x, y, red,
 * green, and blue values of the pixel at the cursor when you click a mouse button or
 * press and hold a mouse button while moving the cursor.  It also lets you zoom in or
 * out.  You can also type in a x and y value to see the color at that location.
 * <br>
 * Originally created for the Jython Environment for Students (JES).
 * <br>
 * Modified to work with DrJava by Barbara Ericson
 * <br>
 * Copyright Georgia Institute of Technology 2004
 * @author Keith McDermottt, gte047w@cc.gatech.edu
 * @author Barb Ericson ericson@cc.gatech.edu
 *
 * Modified 19 July 2007 Pamela Cutter Kalamazoo College
 *    Set the base to be 1 instead of 0 to be consistent with
 *     pictures in JES.
 *
 * Kalamazoo update merged by Buck Scharfnorth 22 May 2008
 *
 * Changed base to use the value SimplePicture._PictureIndexOffset (29 Oct 2008) -Buck
 *
 * May 28 2009: Removed unused changeToBaseOne method. -Buck
 */
class PictureExplorer implements MouseMotionListener, ActionListener, MouseListener
{

 // current x and y index
 private int xIndex = 0;
 private int yIndex = 0;

 //Main gui variables
 private JFrame pictureFrame;
 private JScrollPane scrollPane;

 //information bar variables
 private JLabel xLabel;
 private JButton xPrevButton;
 private JButton yPrevButton;
 private JButton xNextButton;
 private JButton yNextButton;
 private JLabel yLabel;
 private JTextField xValue;
 private JTextField yValue;
 private JLabel rValue;
 private JLabel gValue;
 private JLabel bValue;
 private JLabel colorLabel;
 private JPanel colorPanel;

 // menu components
 private JMenuBar menuBar;
 private JMenu zoomMenu;
 private JMenuItem twentyFive;
 private JMenuItem fifty;
 private JMenuItem seventyFive;
 private JMenuItem hundred;
 private JMenuItem hundredFifty;
 private JMenuItem twoHundred;
 private JMenuItem fiveHundred;

 /** The picture being explored */
 private DigitalPicture picture;

 /** The image icon used to display the picture */
 private ImageIcon scrollImageIcon;

 /** The image display */
 private ImageDisplay imageDisplay;

 /** the zoom factor (amount to zoom) */
 private double zoomFactor;

 /** the number system to use, 0 means starting at 0, 1 means starting at 1 */
 private int numberBase = SimplePicture._PictureIndexOffset;

 /**
  * Constructor that takes a picure to be explored
  * @param picture the picture to explore
  */
 public PictureExplorer(DigitalPicture picture)
 {
   // set the fields
   this.picture=picture;
   zoomFactor=1;

   // create the window and set things up
   createWindow();
 }

 /**
  * Set the title of the frame
  * @param title the title to use in the JFrame
  */
 public void setTitle(String title)
 {
   pictureFrame.setTitle(title);
 }

 /**
  * Method to create and initialize the picture frame
  */
 private void createAndInitPictureFrame()
 {
   pictureFrame = new JFrame(); // create the JFrame
   pictureFrame.setResizable(true);  // allow the user to resize it
   pictureFrame.getContentPane().setLayout(new BorderLayout()); // use border layout
   pictureFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // when close stop
   pictureFrame.setTitle(picture.getTitle());
   PictureExplorerFocusTraversalPolicy newPolicy = new PictureExplorerFocusTraversalPolicy();
   pictureFrame.setFocusTraversalPolicy(newPolicy);

 }

 /**
  * Method to create the menu bar, menus, and menu items
  */
 private void setUpMenuBar()
 {
   //create menu
   menuBar = new JMenuBar();
   zoomMenu = new JMenu("Zoom");
   twentyFive = new JMenuItem("25%");
   fifty = new JMenuItem("50%");
   seventyFive = new JMenuItem("75%");
   hundred = new JMenuItem("100%");
   hundred.setEnabled(false);
   hundredFifty = new JMenuItem("150%");
   twoHundred = new JMenuItem("200%");
   fiveHundred = new JMenuItem("500%");

   // add the action listeners
   twentyFive.addActionListener(this);
   fifty.addActionListener(this);
   seventyFive.addActionListener(this);
   hundred.addActionListener(this);
   hundredFifty.addActionListener(this);
   twoHundred.addActionListener(this);
   fiveHundred.addActionListener(this);

   // add the menu items to the menus
   zoomMenu.add(twentyFive);
   zoomMenu.add(fifty);
   zoomMenu.add(seventyFive);
   zoomMenu.add(hundred);
   zoomMenu.add(hundredFifty);
   zoomMenu.add(twoHundred);
   zoomMenu.add(fiveHundred);
   menuBar.add(zoomMenu);

   // set the menu bar to this menu
   pictureFrame.setJMenuBar(menuBar);
 }

 /**
  * Create and initialize the scrolling image
  */
 private void createAndInitScrollingImage()
 {
   scrollPane = new JScrollPane();

   BufferedImage bimg = picture.getBufferedImage();
   imageDisplay = new ImageDisplay(bimg);
   imageDisplay.addMouseMotionListener(this);
   imageDisplay.addMouseListener(this);
   imageDisplay.setToolTipText("Click a mouse button on a pixel to see the pixel information");
   scrollPane.setViewportView(imageDisplay);
   pictureFrame.getContentPane().add(scrollPane, BorderLayout.CENTER);
 }

 /**
  * Creates the JFrame and sets everything up
  */
 private void createWindow()
 {
   // create the picture frame and initialize it
   createAndInitPictureFrame();

   // set up the menu bar
   setUpMenuBar();

   //create the information panel
   createInfoPanel();

   //creates the scrollpane for the picture
   createAndInitScrollingImage();

   // show the picture in the frame at the size it needs to be
   pictureFrame.pack();
   pictureFrame.setVisible(true);
 }

 /**
  * Method to set up the next and previous buttons for the
  * pixel location information
  */
 private void setUpNextAndPreviousButtons()
 {
   // create the image icons for the buttons
   Icon prevIcon = new ImageIcon(SoundExplorer.class.getResource("leftArrow.gif"),
                                 "previous index");
   Icon nextIcon = new ImageIcon(SoundExplorer.class.getResource("rightArrow.gif"),
                                 "next index");
   // create the arrow buttons
   xPrevButton = new JButton(prevIcon);
   xNextButton = new JButton(nextIcon);
   yPrevButton = new JButton(prevIcon);
   yNextButton = new JButton(nextIcon);

   // set the tool tip text
   xNextButton.setToolTipText("Click to go to the next x value");
   xPrevButton.setToolTipText("Click to go to the previous x value");
   yNextButton.setToolTipText("Click to go to the next y value");
   yPrevButton.setToolTipText("Click to go to the previous y value");

   // set the sizes of the buttons
   int prevWidth = prevIcon.getIconWidth() + 2;
   int nextWidth = nextIcon.getIconWidth() + 2;
   int prevHeight = prevIcon.getIconHeight() + 2;
   int nextHeight = nextIcon.getIconHeight() + 2;
   Dimension prevDimension = new Dimension(prevWidth,prevHeight);
   Dimension nextDimension = new Dimension(nextWidth, nextHeight);
   xPrevButton.setPreferredSize(prevDimension);
   yPrevButton.setPreferredSize(prevDimension);
   xNextButton.setPreferredSize(nextDimension);
   yNextButton.setPreferredSize(nextDimension);

   // handle previous x button press
   xPrevButton.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent evt) {
       xIndex--;
       if (xIndex < 0)
         xIndex = 0;
       displayPixelInformation(xIndex,yIndex);
     }
   });

   // handle previous y button press
   yPrevButton.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent evt) {
       yIndex--;
       if (yIndex < 0)
         yIndex = 0;
       displayPixelInformation(xIndex,yIndex);
     }
   });

   // handle next x button press
   xNextButton.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent evt) {
       xIndex++;
       if (xIndex >= picture.getWidth())
         xIndex = picture.getWidth() - 1;
       displayPixelInformation(xIndex,yIndex);
     }
   });

   // handle next y button press
   yNextButton.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent evt) {
       yIndex++;
       if (yIndex >= picture.getHeight())
         yIndex = picture.getHeight() - 1;
       displayPixelInformation(xIndex,yIndex);
     }
   });
 }

 /**
  * Create the pixel location panel
  * @param labelFont the font for the labels
  * @return the location panel
  */
 public JPanel createLocationPanel(Font labelFont) {

   // create a location panel
   JPanel locationPanel = new JPanel();
   locationPanel.setLayout(new FlowLayout());
   Box hBox = Box.createHorizontalBox();

   // create the labels
   xLabel = new JLabel("X:");
   yLabel = new JLabel("Y:");

   // create the text fields
   xValue = new JTextField(Integer.toString(xIndex + numberBase),6);
   xValue.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent e) {
       displayPixelInformation(xValue.getText(),yValue.getText());
     }
   });
   yValue = new JTextField(Integer.toString(yIndex + numberBase),6);
   yValue.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent e) {
      displayPixelInformation(xValue.getText(),yValue.getText());
     }
   });

   // set up the next and previous buttons
   setUpNextAndPreviousButtons();

   // set up the font for the labels
   xLabel.setFont(labelFont);
   yLabel.setFont(labelFont);
   xValue.setFont(labelFont);
   yValue.setFont(labelFont);

   // add the items to the vertical box and the box to the panel
   hBox.add(Box.createHorizontalGlue());
   hBox.add(xLabel);
   hBox.add(xPrevButton);
   hBox.add(xValue);
   hBox.add(xNextButton);
   hBox.add(Box.createHorizontalStrut(10));
   hBox.add(yLabel);
   hBox.add(yPrevButton);
   hBox.add(yValue);
   hBox.add(yNextButton);
   locationPanel.add(hBox);
   hBox.add(Box.createHorizontalGlue());

   return locationPanel;
 }

 /**
  * Create the color information panel
  * @param labelFont the font to use for labels
  * @return the color information panel
  */
 private JPanel createColorInfoPanel(Font labelFont)
 {
   // create a color info panel
   JPanel colorInfoPanel = new JPanel();
   colorInfoPanel.setLayout(new FlowLayout());

   // get the pixel at the x and y
   Pixel pixel = new Pixel(picture,xIndex,yIndex);

   // create the labels
   rValue = new JLabel("R: " + pixel.getRed());
   gValue = new JLabel("G: " + pixel.getGreen());
   bValue = new JLabel("B: " + pixel.getBlue());

   // create the sample color panel and label
   colorLabel = new JLabel("Color at location: ");
   colorPanel = new JPanel();
   colorPanel.setBorder(new LineBorder(Color.black,1));

   // set the color sample to the pixel color
   colorPanel.setBackground(pixel.getColor());

   // set the font
   rValue.setFont(labelFont);
   gValue.setFont(labelFont);
   bValue.setFont(labelFont);
   colorLabel.setFont(labelFont);
   colorPanel.setPreferredSize(new Dimension(25,25));

   // add items to the color information panel
   colorInfoPanel.add(rValue);
   colorInfoPanel.add(gValue);
   colorInfoPanel.add(bValue);
   colorInfoPanel.add(colorLabel);
   colorInfoPanel.add(colorPanel);

   return colorInfoPanel;
 }

 /**
  * Creates the North JPanel with all the pixel location
  * and color information
  */
 private void createInfoPanel()
 {
   // create the info panel and set the layout
   JPanel infoPanel = new JPanel();
   infoPanel.setLayout(new BorderLayout());

   // create the font
   Font largerFont = new Font(infoPanel.getFont().getName(),
                              infoPanel.getFont().getStyle(),14);

   // create the pixel location panel
   JPanel locationPanel = createLocationPanel(largerFont);

   // create the color informaiton panel
   JPanel colorInfoPanel = createColorInfoPanel(largerFont);

   // add the panels to the info panel
   infoPanel.add(BorderLayout.NORTH,locationPanel);
   infoPanel.add(BorderLayout.SOUTH,colorInfoPanel);

   // add the info panel
   pictureFrame.getContentPane().add(BorderLayout.NORTH,infoPanel);
 }

 /**
  * Method to check that the current position is in the viewing area and if
  * not scroll to center the current position if possible
  */
 public void checkScroll()
 {
   // get the x and y position in pixels
   int xPos = (int) (xIndex * zoomFactor);
   int yPos = (int) (yIndex * zoomFactor);

   // only do this if the image is larger than normal
   if (zoomFactor > 1) {

     // get the rectangle that defines the current view
     JViewport viewport = scrollPane.getViewport();
     Rectangle rect = viewport.getViewRect();
     int rectMinX = (int) rect.getX();
     int rectWidth = (int) rect.getWidth();
     int rectMaxX = rectMinX + rectWidth - 1;
     int rectMinY = (int) rect.getY();
     int rectHeight = (int) rect.getHeight();
     int rectMaxY = rectMinY + rectHeight - 1;

     // get the maximum possible x and y index
     int maxIndexX = (int) (picture.getWidth() * zoomFactor) - rectWidth - 1;
     int maxIndexY = (int) (picture.getHeight() * zoomFactor) - rectHeight - 1;

     // calculate how to position the current position in the middle of the viewing
     // area
     int viewX = xPos - (int) (rectWidth / 2);
     int viewY = yPos - (int) (rectHeight / 2);

     // reposition the viewX and viewY if outside allowed values
     if (viewX < 0)
       viewX = 0;
     else if (viewX > maxIndexX)
       viewX = maxIndexX;
     if (viewY < 0)
       viewY = 0;
     else if (viewY > maxIndexY)
       viewY = maxIndexY;

     // move the viewport upper left point
     viewport.scrollRectToVisible(new Rectangle(viewX,viewY,rectWidth,rectHeight));
   }
 }

 /**
  * Zooms in the on picture by scaling the image.
  * It is extremely memory intensive.
  * @param factor the amount to zoom by
  */
 public void zoom(double factor)
 {
   // save the current zoom factor
   zoomFactor = factor;

   // calculate the new width and height and get an image that size
   int width = (int) (picture.getWidth()*zoomFactor);
   int height = (int) (picture.getHeight()*zoomFactor);
   BufferedImage bimg = picture.getBufferedImage();

   // set the scroll image icon to the new image
   imageDisplay.setImage(bimg.getScaledInstance(width, height, Image.SCALE_DEFAULT));
   imageDisplay.setCurrentX((int) (xIndex * zoomFactor));
   imageDisplay.setCurrentY((int) (yIndex * zoomFactor));
   imageDisplay.revalidate();
   checkScroll();  // check if need to reposition scroll
 }

 /**
  * Repaints the image on the scrollpane.
  */
 public void repaint()
 {
   pictureFrame.repaint();
 }

 //****************************************//
 //               Event Listeners          //
 //****************************************//

 /**
  * Called when the mouse is dragged (button held down and moved)
  * @param e the mouse event
  */
 public void mouseDragged(MouseEvent e)
 {
   displayPixelInformation(e);
 }

 /**
  * Method to check if the given x and y are in the picture
  * @param x the horiztonal value
  * @param y the vertical value
  * @return true if the x and y are in the picture and false otherwise
  */
 private boolean isLocationInPicture(int x, int y)
 {
   boolean result = false; // the default is false
   if (x >= 0 && x < picture.getWidth() &&
       y >= 0 && y < picture.getHeight())
     result = true;

   return result;
 }

 /**
  * Method to display the pixel information from the passed x and y but
  * also converts x and y from strings
  * @param xString the x value as a string from the user
  * @param yString the y value as a string from the user
  */
 public void displayPixelInformation(String xString, String yString)
 {
   int x = -1;
   int y = -1;
   try {
     x = Integer.parseInt(xString);
     x = x - numberBase;
     y = Integer.parseInt(yString);
     y = y - numberBase;
   } catch (Exception ex) {
   }

   if (x >= 0 && y >= 0) {
     displayPixelInformation(x,y);
   }
 }

 /**
  * Method to display pixel information for the passed x and y
  * @param pictureX the x value in the picture
  * @param pictureY the y value in the picture
  */
 private void displayPixelInformation(int pictureX, int pictureY)
 {
   // check that this x and y is in range
   if (isLocationInPicture(pictureX, pictureY))
   {
     // save the current x and y index
     xIndex = pictureX;
     yIndex = pictureY;

     // get the pixel at the x and y
     Pixel pixel = new Pixel(picture,xIndex,yIndex);

     // set the values based on the pixel
     xValue.setText(Integer.toString(xIndex  + numberBase));
     yValue.setText(Integer.toString(yIndex + numberBase));
     rValue.setText("R: " + pixel.getRed());
     gValue.setText("G: " + pixel.getGreen());
     bValue.setText("B: " + pixel.getBlue());
     colorPanel.setBackground(new Color(pixel.getRed(), pixel.getGreen(), pixel.getBlue()));

   }
   else
   {
     clearInformation();
   }

   // notify the image display of the current x and y
   imageDisplay.setCurrentX((int) (xIndex * zoomFactor));
   imageDisplay.setCurrentY((int) (yIndex * zoomFactor));
 }

 /**
  * Method to display pixel information based on a mouse event
  * @param e a mouse event
  */
 private void displayPixelInformation(MouseEvent e)
 {

   // get the cursor x and y
   int cursorX = e.getX();
   int cursorY = e.getY();

   // get the x and y in the original (not scaled image)
   int pictureX = (int) (cursorX / zoomFactor + numberBase);
   int pictureY = (int) (cursorY / zoomFactor + numberBase);

   // display the information for this x and y
   displayPixelInformation(pictureX,pictureY);

 }

 /**
  * Method to clear the labels and current color and reset the
  * current index to -1
  */
 private void clearInformation()
 {
   xValue.setText("N/A");
   yValue.setText("N/A");
   rValue.setText("R: N/A");
   gValue.setText("G: N/A");
   bValue.setText("B: N/A");
   colorPanel.setBackground(Color.black);
   xIndex = -1;
   yIndex = -1;
 }

 /**
  * Method called when the mouse is moved with no buttons down
  * @param e the mouse event
  */
 public void mouseMoved(MouseEvent e)
 {}

 /**
  * Method called when the mouse is clicked
  * @param e the mouse event
  */
 public void mouseClicked(MouseEvent e)
 {
   displayPixelInformation(e);
 }

 /**
  * Method called when the mouse button is pushed down
  * @param e the mouse event
  */
 public void mousePressed(MouseEvent e)
 {
   displayPixelInformation(e);
 }

 /**
  * Method called when the mouse button is released
  * @param e the mouse event
  */
 public void mouseReleased(MouseEvent e)
 {
 }

 /**
  * Method called when the component is entered (mouse moves over it)
  * @param e the mouse event
  */
 public void mouseEntered(MouseEvent e)
 {
 }

 /**
  * Method called when the mouse moves over the component
  * @param e the mouse event
  */
 public void mouseExited(MouseEvent e)
 {
 }

 /**
  * Method to enable all menu commands
  */
 private void enableZoomItems()
 {
   twentyFive.setEnabled(true);
   fifty.setEnabled(true);
   seventyFive.setEnabled(true);
   hundred.setEnabled(true);
   hundredFifty.setEnabled(true);
   twoHundred.setEnabled(true);
   fiveHundred.setEnabled(true);
 }

 /**
  * Controls the zoom menu bar
  *
  * @param a the ActionEvent
  */
 public void actionPerformed(ActionEvent a)
 {

   if(a.getActionCommand().equals("Update"))
   {
     this.repaint();
   }

   if(a.getActionCommand().equals("25%"))
   {
     this.zoom(.25);
     enableZoomItems();
     twentyFive.setEnabled(false);
   }

   if(a.getActionCommand().equals("50%"))
   {
     this.zoom(.50);
     enableZoomItems();
     fifty.setEnabled(false);
   }

   if(a.getActionCommand().equals("75%"))
   {
     this.zoom(.75);
     enableZoomItems();
     seventyFive.setEnabled(false);
   }

   if(a.getActionCommand().equals("100%"))
   {
     this.zoom(1.0);
     enableZoomItems();
     hundred.setEnabled(false);
   }

   if(a.getActionCommand().equals("150%"))
   {
     this.zoom(1.5);
     enableZoomItems();
     hundredFifty.setEnabled(false);
   }

   if(a.getActionCommand().equals("200%"))
   {
     this.zoom(2.0);
     enableZoomItems();
     twoHundred.setEnabled(false);
   }

   if(a.getActionCommand().equals("500%"))
   {
     this.zoom(5.0);
     enableZoomItems();
     fiveHundred.setEnabled(false);
   }
 }

 /**
  * Test Main.  It will ask you to pick a file and then show it
  */
 public static void main( String args[])
 {
   Picture p = new Picture(FileChooser.pickAFile());
   PictureExplorer test = new PictureExplorer(p);

 }

 /**
  * Class for establishing the focus for the textfields
  */
 private class PictureExplorerFocusTraversalPolicy
                 extends FocusTraversalPolicy {

        /**
         * Method to get the next component for focus
         */
        public Component getComponentAfter(Container focusCycleRoot,
                                           Component aComponent) {
            if (aComponent.equals(xValue))
              return yValue;
            else
              return xValue;
        }

        /**
         * Method to get the previous component for focus
         */
         public Component getComponentBefore(Container focusCycleRoot,
                                       Component aComponent) {
            if (aComponent.equals(xValue))
              return yValue;
            else
              return xValue;
         }

         public Component getDefaultComponent(Container focusCycleRoot) {
            return xValue;
        }

        public Component getLastComponent(Container focusCycleRoot) {
            return yValue;
        }

        public Component getFirstComponent(Container focusCycleRoot) {
            return xValue;
        }
    }

}

class SimplePicture implements DigitalPicture
{

  /////////////////////// Fields /////////////////////////
  /**
   * Constant for the index base (0 or 1)
   */
  public static final int _PictureIndexOffset = 0;

  /**
   * the file name associated with the simple picture
   */
  private String fileName;

  /**
   * the title of the simple picture
   */
  private String title;

  /**
   * buffered image to hold pixels for the simple picture
   */
  private BufferedImage bufferedImage;

  /**
   * frame used to display the simple picture
   */
  private PictureFrame pictureFrame;

  /**
   * extension for this file (jpg or bmp)
   */
  private String extension;


 /////////////////////// Constructors /////////////////////////

 /**
  * Constructor that takes no arguments. All fields will be null.
  * A no-argument constructor must be given in order for a class to
  * be able to be subclassed. By default all subclasses will implicitly
  * call this in their parent's no argument constructor unless a
  * different call to super() is explicitly made as the first line
  * of code in a constructor.
  */
 public SimplePicture()
 {this(200,100);}

 /**
  * Constructor that takes a file name and uses the file to create
  * a picture
  * @param fileName the file name to use in creating the picture
  */
 public SimplePicture(String fileName) {
   // load the picture into the buffered image
   load(fileName);
 }

 /**
  * Constructor that takes the width and height desired for a picture and
  * creates a buffered image of that size. This constructor doesn't
  * show the picture.
  * @param width the desired width
  * @param height the desired height
  */
 public  SimplePicture(int width, int height)
 {
   bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
   title = "None";
   fileName = "None";
   extension = "jpg";
   setAllPixelsToAColor(Color.white);
 }

 /**
  * Constructor that takes the width and height desired for a picture and
  * creates a buffered image of that size.  It also takes the
  * color to use for the background of the picture.
  * @param width the desired width
  * @param height the desired height
  * @param theColor the background color for the picture
  */
 public  SimplePicture(int width, int height, Color theColor)
 {
   this(width,height);
   setAllPixelsToAColor(theColor);
 }

 /**
  * Constructor that takes a picture to copy information from
  * @param copyPicture the picture to copy from
  */
 public SimplePicture(SimplePicture copyPicture)
 {
   if (copyPicture.fileName != null)
   {
      this.fileName = new String(copyPicture.fileName);
      this.extension = copyPicture.extension;
   }
   if (copyPicture.title != null)
      this.title = new String(copyPicture.title);
   if (copyPicture.bufferedImage != null)
   {
     this.bufferedImage = new BufferedImage(copyPicture.getWidth(),
                                            copyPicture.getHeight(),
                                            BufferedImage.TYPE_INT_RGB);
     this.copyPicture(copyPicture);
   }
 }

 /**
  * Constructor that takes a buffered image
  * @param image the buffered image
  */
 public SimplePicture(BufferedImage image)
 {
   this.bufferedImage = image;
   title = "None";
   fileName = "None";
   extension = "jpg";
 }

 ////////////////////////// Methods //////////////////////////////////

 /**
  * Method to get the extension for this picture
  * @return the extension (jpg or bmp)
  */
 public String getExtension() { return extension; }


 /**
  * Method that will copy all of the passed source picture into
  * the current picture object
  * @param sourcePicture the picture object to copy
  */
 public void copyPicture(SimplePicture sourcePicture)
 {
   Pixel sourcePixel = null;
   Pixel targetPixel = null;

   // loop through the columns
   for (int sourceX = 0, targetX = 0;
        sourceX < sourcePicture.getWidth() &&
        targetX < this.getWidth();
        sourceX++, targetX++)
   {
     // loop through the rows
     for (int sourceY = 0, targetY = 0;
          sourceY < sourcePicture.getHeight() &&
          targetY < this.getHeight();
          sourceY++, targetY++)
     {
       sourcePixel = sourcePicture.getPixel(sourceX,sourceY);
       targetPixel = this.getPixel(targetX,targetY);
       targetPixel.setColor(sourcePixel.getColor());
     }
   }
 }

 /**
  * Method to set the color in the picture to the passed color
  * @param color the color to set to
  */
 public void setAllPixelsToAColor(Color color) {
    Graphics2D g = (Graphics2D) this.getBufferedImage().getGraphics();
    g.setColor(color);
    g.fillRect(0, 0, this.getWidth(), this.getHeight() );
 }


 /**
  * Method to get the buffered image
  * @return the buffered image
  */
 public BufferedImage getBufferedImage()
 {
    return bufferedImage;
 }

 /**
  * Method to get a graphics object for this picture to use to draw on
  * @return a graphics object to use for drawing
  */
 public Graphics getGraphics()
 {
   return bufferedImage.getGraphics();
 }

 /**
  * Method to get a Graphics2D object for this picture which can
  * be used to do 2D drawing on the picture
  * @return a Graphics2D object to use for drawing
  */
 public Graphics2D createGraphics()
 {
   return bufferedImage.createGraphics();
 }

 /**
  * Method to get the file name associated with the picture
  * @return the file name associated with the picture
  */
 public String getFileName() { return fileName; }

 /**
  * Method to set the file name
  * @param name the full pathname of the file
  */
 public void setFileName(String name)
 {
   fileName = name;
 }

 /**
  * Method to get the title of the picture
  * @return the title of the picture
  */
 public String getTitle()
 { return title; }

 /**
  * Method to set the title for the picture
  * @param title the title to use for the picture
  */
 public void setTitle(String title)
 {
   this.title = title;
   if (pictureFrame != null)
       pictureFrame.setTitle(title);
 }

 /**
  * Method to get the width of the picture in pixels
  * @return the width of the picture in pixels
  */
 public int getWidth() { return bufferedImage.getWidth(); }

 /**
  * Method to get the height of the picture in pixels
  * @return the height of the picture in pixels
  */
 public int getHeight() { return bufferedImage.getHeight(); }

 /**
  * Method to get the picture frame for the picture
  * @return the picture frame associated with this picture
  * (it may be null)
  */
 public PictureFrame getPictureFrame() { return pictureFrame; }

 /**
  * Method to set the picture frame for this picture
  * @param pictureFrame the picture frame to use
  */
 public void setPictureFrame(PictureFrame pictureFrame)
 {
   // set this picture objects' picture frame to the passed one
   this.pictureFrame = pictureFrame;
 }

 /**
  * Method to get an image from the picture
  * @return the buffered image since it is an image
  */
 public Image getImage()
 {
   return bufferedImage;
 }

 /**
  * Method to return the pixel value as an int for the given x and y location
  * @param x the x coordinate of the pixel
  * @param y the y coordinate of the pixel
  * @return the pixel value as an integer (alpha, red, green, blue)
  */
 public int getBasicPixel(int x, int y)
 {
    return bufferedImage.getRGB(x,y);
 }

 /**
  * Method to set the value of a pixel in the picture from an int
  * @param x the x coordinate of the pixel
  * @param y the y coordinate of the pixel
  * @param rgb the new rgb value of the pixel (alpha, red, green, blue)
  */
 public void setBasicPixel(int x, int y, int rgb)
 {
   bufferedImage.setRGB(x,y,rgb);
 }

 /**
  * Method to get a pixel object for the given x and y location
  * @param x the x location of the pixel in the picture
  * @param y the y location of the pixel in the picture
  * @return a Pixel object for this location
  */
 public Pixel getPixel(int x, int y)
 {
   // create the pixel object for this picture and the given x and y location
   Pixel pixel = new Pixel(this,x,y);
   return pixel;
 }

 /**
  * Method to get a one-dimensional array of Pixels for this simple picture
  * @return a one-dimensional array of Pixel objects starting with y=0
  * to y=height-1 and x=0 to x=width-1.
  */

public Pixel[][] get2DArray()
{
   int width = getWidth();
   int height = getHeight();
   Pixel[][] pixelArray = new Pixel[width][height];

   // loop through height rows from top to bottom
   for (int row = 0; row < width; row++)
     for (int col = 0; col < height; col++)
       pixelArray[row][col] = new Pixel(this,row,col);

   return pixelArray;
}
 public Pixel[] getPixels()
 {
   int width = getWidth();
   int height = getHeight();
   Pixel[] pixelArray = new Pixel[width * height];

   // loop through height rows from top to bottom
   for (int row = 0; row < height; row++)
     for (int col = 0; col < width; col++)
       pixelArray[row * width + col] = new Pixel(this,col,row);

   return pixelArray;
 }

 /**
  * Method to load the buffered image with the passed image
  * @param image the image to use
  */
 public void load(Image image)
 {
   // get a graphics context to use to draw on the buffered image
   Graphics2D graphics2d = bufferedImage.createGraphics();

   // draw the image on the buffered image starting at 0,0
   graphics2d.drawImage(image,0,0,null);

   // show the new image
   show();
 }

 /**
  * Method to show the picture in a picture frame
  */
 public void show()
 {
    // if there is a current picture frame then use it
   if (pictureFrame != null)
     pictureFrame.updateImageAndShowIt();

   // else create a new picture frame with this picture
   else
     pictureFrame = new PictureFrame(this);
 }

 /**
  * Method to hide the picture
  */
 public void hide()
 {
   if (pictureFrame != null)
     pictureFrame.setVisible(false);
 }

 /**
  * Method to make this picture visible or not
  * @param flag true if you want it visible else false
  */
 public void setVisible(boolean flag)
 {
   if (flag)
     this.show();
   else
     this.hide();
 }

 /**
  * Method to open a picture explorer on a copy of this simple picture
  */
 public void explore()
 {
   // create a copy of the current picture and explore it
   new PictureExplorer(new SimplePicture(this));
 }

 /**
  * Method to force the picture to redraw itself. This is very
  * useful after you have changed the pixels in a picture.
  */
 public void repaint()
 {
   // if there is a picture frame tell it to repaint
   if (pictureFrame != null)
     pictureFrame.repaint();

   // else create a new picture frame
   else
     pictureFrame = new PictureFrame(this);
 }

 /**
  * Method to load the picture from the passed file name
  * @param fileName the file name to use to load the picture from
  */
 public void loadOrFail(String fileName) throws IOException
 {
    // set the current picture's file name
   this.fileName = fileName;

   // set the extension
   int posDot = fileName.indexOf('.');
   if (posDot >= 0)
     this.extension = fileName.substring(posDot + 1);

   // if the current title is null use the file name
   if (title == null || title == "None")
     title = fileName;

   File file = new File(this.fileName);

   if (!file.canRead())
   {
     // try adding the media path
     file = new File(FileChooser.getMediaPath(this.fileName));
     if (!file.canRead())
     {
       throw new IOException(this.fileName +
                             " could not be opened. Check that you specified the path");
     }
   }

   bufferedImage = ImageIO.read(file);
 }

 /**
  * Method to load the contents of the picture to a file without throwing exceptions
  * @param fileName the name of the file to load the picture from
  * @return true if success else false
  */
 public boolean load(String fileName)
 {
     try {
         this.loadOrFail(fileName);
         return true;

     } catch (Exception ex) {
         System.out.println("There was an error trying to open " + fileName);
         System.out.println(ex);
         // ex.printStackTrace();
         bufferedImage = new BufferedImage(600,200,
                                           BufferedImage.TYPE_INT_RGB);
         addMessage("Couldn't load " + fileName,5,100);
         return false;
     }

 }

 /**
  * Method to load the picture from the passed file name
  * this just calls load(fileName) and is for name compatibility
  * @param fileName the file name to use to load the picture from
  * @return true if success else false
  */
 public boolean loadImage(String fileName)
 {
     return load(fileName);
}

 /**
  * Method to draw a message as a string on the buffered image
  * @param message the message to draw on the buffered image
  * @param xPos the leftmost point of the string in x
  * @param yPos the bottom of the string in y
  */
 public void addMessage(String message, int xPos, int yPos)
 {
   // get a graphics context to use to draw on the buffered image
   Graphics2D graphics2d = bufferedImage.createGraphics();

   // set the color to white
   graphics2d.setPaint(Color.white);

   // set the font to Helvetica bold style and size 16
   graphics2d.setFont(new Font("Helvetica",Font.BOLD,16));

   // draw the message
   graphics2d.drawString(message,xPos,yPos);

 }

 /**
  * Method to draw a string at the given location on the picture
  * @param text the text to draw
  * @param xPos the left x for the text
  * @param yPos the top y for the text
  */
 public void drawString(String text, int xPos, int yPos)
 {
   addMessage(text,xPos,yPos);
 }

 /**
   * Method to create a new picture by scaling the current
   * picture by the given x and y factors
   * @param xFactor the amount to scale in x
   * @param yFactor the amount to scale in y
   * @return the resulting picture
   */
  public Picture scale(double xFactor, double yFactor)
  {
    // set up the scale tranform
    AffineTransform scaleTransform = new AffineTransform();
    scaleTransform.scale(xFactor,yFactor);

    // create a new picture object that is the right size
    Picture result = new Picture((int) (getWidth() * xFactor),
                                 (int) (getHeight() * yFactor));

    // get the graphics 2d object to draw on the result
    Graphics graphics = result.getGraphics();
    Graphics2D g2 = (Graphics2D) graphics;

    // draw the current image onto the result image scaled
    g2.drawImage(this.getImage(),scaleTransform,null);

    return result;
  }

  /**
   * Method to create a new picture of the passed width.
   * The aspect ratio of the width and height will stay
   * the same.
   * @param width the desired width
   * @return the resulting picture
   */
  public Picture getPictureWithWidth(int width)
  {
    // set up the scale tranform
    double xFactor = (double) width / this.getWidth();
    Picture result = scale(xFactor,xFactor);
    return result;
  }

  /**
   * Method to create a new picture of the passed height.
   * The aspect ratio of the width and height will stay
   * the same.
   * @param height the desired height
   * @return the resulting picture
   */
  public Picture getPictureWithHeight(int height)
  {
    // set up the scale tranform
    double yFactor = (double) height / this.getHeight();
    Picture result = scale(yFactor,yFactor);
    return result;
  }

 /**
  * Method to load a picture from a file name and show it in a picture frame
  * @param fileName the file name to load the picture from
  * @return true if success else false
  */
 public boolean loadPictureAndShowIt(String fileName)
 {
   boolean result = true;  // the default is that it worked

   // try to load the picture into the buffered image from the file name
   result = load(fileName);

   // show the picture in a picture frame
   show();

   return result;
 }

 /**
  * Method to write the contents of the picture to a file with
  * the passed name
  * @param fileName the name of the file to write the picture to
  */
 public void writeOrFail(String fileName) throws IOException
 {
   String extension = this.extension; // the default is current

   // create the file object
   File file = new File(fileName);
   File fileLoc = file.getParentFile();

   // canWrite is true only when the file exists already! (alexr)
   if (null != fileLoc && !fileLoc.canWrite()) {
       // System.err.println("can't write the file but trying anyway? ...");
        throw new IOException(fileName +
        " could not be opened. Check to see if you can write to the directory.");
   }

   // get the extension
   int posDot = fileName.indexOf('.');
   if (posDot >= 0)
       extension = fileName.substring(posDot + 1);

   // write the contents of the buffered image to the file as jpeg
   ImageIO.write(bufferedImage, extension, file);

 }

 /**
  * Method to write the contents of the picture to a file with
  * the passed name without throwing exceptions
  * @param fileName the name of the file to write the picture to
  * @return true if success else false
  */
 public boolean write(String fileName)
 {
     try {
         this.writeOrFail(fileName);
         return true;
     } catch (Exception ex) {
         System.out.println("There was an error trying to write " + fileName);
         ex.printStackTrace();
         return false;
     }

 }

 /**
  * Method to set the media path by setting the directory to use
  * @param directory the directory to use for the media path
  */
 public static void setMediaPath(String directory) {
   FileChooser.setMediaPath(directory);
 }

 /**
  * Method to get the directory for the media
  * @param fileName the base file name to use
  * @return the full path name by appending
  * the file name to the media directory
  */
 public static String getMediaPath(String fileName) {
   return FileChooser.getMediaPath(fileName);
 }

  /**
   * Method to get the coordinates of the enclosing rectangle after this
   * transformation is applied to the current picture
   * @return the enclosing rectangle
   */
  public Rectangle2D getTransformEnclosingRect(AffineTransform trans)
  {
    int width = getWidth();
    int height = getHeight();
    double maxX = width - 1;
    double maxY = height - 1;
    double minX, minY;
    Point2D.Double p1 = new Point2D.Double(0,0);
    Point2D.Double p2 = new Point2D.Double(maxX,0);
    Point2D.Double p3 = new Point2D.Double(maxX,maxY);
    Point2D.Double p4 = new Point2D.Double(0,maxY);
    Point2D.Double result = new Point2D.Double(0,0);
    Rectangle2D.Double rect = null;

    // get the new points and min x and y and max x and y
    trans.deltaTransform(p1,result);
    minX = result.getX();
    maxX = result.getX();
    minY = result.getY();
    maxY = result.getY();
    trans.deltaTransform(p2,result);
    minX = Math.min(minX,result.getX());
    maxX = Math.max(maxX,result.getX());
    minY = Math.min(minY,result.getY());
    maxY = Math.max(maxY,result.getY());
    trans.deltaTransform(p3,result);
    minX = Math.min(minX,result.getX());
    maxX = Math.max(maxX,result.getX());
    minY = Math.min(minY,result.getY());
    maxY = Math.max(maxY,result.getY());
    trans.deltaTransform(p4,result);
    minX = Math.min(minX,result.getX());
    maxX = Math.max(maxX,result.getX());
    minY = Math.min(minY,result.getY());
    maxY = Math.max(maxY,result.getY());

    // create the bounding rectangle to return
    rect = new Rectangle2D.Double(minX,minY,maxX - minX + 1, maxY - minY + 1);
    return rect;
  }

 /**
  * Method to return a string with information about this picture
  * @return a string with information about the picture
  */
 public String toString()
 {
   String output = "Simple Picture, filename " + fileName +
     " height " + getHeight() + " width " + getWidth();
   return output;
 }

} // end of SimplePicture class
/**
 * A class that represents a picture.  This class inherits from
 * SimplePicture and allows the student to add functionality to
 * the Picture class. In JES, many "extra" features are already present,
 * available through OO-notation for the advanced media computation
 * students.
 * <br>
 * Copyright Georgia Institute of Technology 2004-2005
 * @author Barbara Ericson ericson@cc.gatech.edu
 *
 * Modified 6 July 2007 Pam Cutter Kalamazoo College
 * 	  Added a 3-param constructor to allow the construction of
 * 		pictures of different colors
 * 	  Added a copyInto method which allows copying as much of
 * 		this picture as will fit into a destination picture
 *    Added a crop method which returns a new picture which is a
 * 		specified portion of this picture
 *
 * Kalamazoo additional methods and improved comments merged by Buck Scharfnorth 22 May 2008
 */

public class Picture extends SimplePicture
{
    public void show()
    {
        new PictureFrame(this);
    }

    
  ///////////////////// constructors //////////////////////////////////

  /**
   * Constructor that takes no arguments
   */
  public Picture ()
  {
    /* not needed but use it to show students the implicit call to super()
     * child constructors always call a parent constructor
     */
    super();
  }

  /**
   * Constructor that takes a file name and creates the picture
   * @param fileName the name of the file to create the picture from
   */
  public Picture(String fileName)
  {
    // let the parent class handle this fileName
    super(fileName);
  }

  /**
   * Constructor that takes the width and height
   * @param width the width of the desired picture
   * @param height the height of the desired picture
   */
  public Picture(int width, int height)
  {
    // let the parent class handle this width and height
    super(width,height);
  }

/**
   * Constructor that takes the width and height, and a color
   * @param width the width of the desired picture
   * @param height the height of the desired picture
   * @param color the color of the desired picture
   */
  public Picture(int width, int height, Color color)
  {
    // let the parent class handle this width and height
    super(width,height,color);
  }

  /**
   * Constructor that takes a picture and creates a
   * copy of that picture.
   * @param copyPicture the picture to be copied
   */
  public Picture(Picture copyPicture)
  {
    // let the parent class do the copy
    super(copyPicture);
  }

  /**
   * Constructor that takes a buffered image
   * @param image the buffered image to use
   */
  public Picture(BufferedImage image)
  {
    super(image);
  }
  ////////////////////// methods ///////////////////////////////////////

  /**
   * Method to return a string with information about this picture.
   * @return a string with information about the picture such as fileName,
   * height and width.
   */
  public String toString()
  {
    String output = "Picture, filename " + getFileName() +
      " height " + getHeight()
      + " width " + getWidth();
    return output;
  }

/* adding graphics to pictures, for use in JES. (added by alexr, Oct 2006) */

    /**
     * Method to draw a line between two points on a picture
     * @param acolor the color of the line
     * @param x1 the x-coordinate of the first point
     * @param y1 the y-coordinate of the first point
     * @param x2 the x-coordinate of the second point
     * @param y2 the y-coordinate of the second point
     */
    public void addLine(Color acolor, int x1, int y1, int x2, int y2) {
        Graphics g = this.getBufferedImage().getGraphics();
        g.setColor(acolor);
        g.drawLine(x1 - SimplePicture._PictureIndexOffset,y1 - SimplePicture._PictureIndexOffset,x2 - SimplePicture._PictureIndexOffset,y2 - SimplePicture._PictureIndexOffset);
    }

    /**
     * Method to add a line of text to a picture
     *    @param acolor the color of the text
     *    @param x the x-coordinate of the bottom left corner of the text
     *    @param y the y-coordinate of the bottom left corner of the text
     *    @param string the text to be added to the picture
     */
    public void addText(Color acolor, int x, int y, String string) {
        Graphics g = this.getBufferedImage().getGraphics();
        g.setColor(acolor);
        g.drawString(string, x - SimplePicture._PictureIndexOffset, y - SimplePicture._PictureIndexOffset);
    }

    /**
     * Method to add text to a picture withe a particular font style
     *    @param acolor the color of the text
     *    @param x the x-coordinate of the bottom left corner of the text
     *    @param y the y-coordinate of the bottom left corner of the text
     *    @param string the text to be added to the picture
     *    @param style the font style to be used
     */
    public void addTextWithStyle(Color acolor, int x, int y, String string, Font style) {
        Graphics g = this.getBufferedImage().getGraphics();
        g.setColor(acolor);
        g.setFont(style);
        g.drawString(string, x - SimplePicture._PictureIndexOffset, y - SimplePicture._PictureIndexOffset);
    }

    /**
     * Method to draw the outline of a rectangle on a picture.
     *    @param acolor the color of the rectangle
     *    @param x the x-coordinate of the upper-left corner of the rectangle
     *    @param y the y-coordinate of the upper-left corner of the rectangle
     *    @param w the width of the rectangle
     *    @param h the height of the rectangle
     */
    public void addRect(Color acolor, int x, int y, int w, int h) {
        Graphics g = this.getBufferedImage().getGraphics();
        g.setColor(acolor);
        g.drawRect(x - SimplePicture._PictureIndexOffset,y - SimplePicture._PictureIndexOffset,w,h);
    }

    /**
     * Method to draw a solid rectangle on a picture.
     *    @param acolor the color of the rectangle
     *    @param x the x-coordinate of the upper-left corner of the rectangle
     *    @param y the y-coordinate of the upper-left corner of the rectangle
     *    @param w the width of the rectangle
     *    @param h the height of the rectangle
     */
    public void addRectFilled(Color acolor, int x, int y, int w, int h) {
        Graphics g = this.getBufferedImage().getGraphics();
        g.setColor(acolor);
        g.fillRect(x - SimplePicture._PictureIndexOffset,y - SimplePicture._PictureIndexOffset,w,h);
    }

    /**
     * Method to draw a solid oval on a picture.
     *    @param acolor the color of the oval
     *    @param x the x-coordinate of the upper-left corner of the bounding rectangle for the oval
     *    @param y the y-coordinate of the upper-left corner of the bounding rectangle for the oval
     *    @param w the width of the oval
     *    @param h the height of the oval
     */
    public void addOvalFilled(Color acolor, int x, int y, int w, int h) {
        Graphics g = this.getBufferedImage().getGraphics();
        g.setColor(acolor);
        g.fillOval(x - SimplePicture._PictureIndexOffset,y - SimplePicture._PictureIndexOffset,w,h);
    }

    /**
     * Method to draw the outline of an oval on a picture.
     *    @param acolor the color of the oval
     *    @param x the x-coordinate of the upper-left corner of the bounding rectangle for the oval
     *    @param y the y-coordinate of the upper-left corner of the bounding rectangle for the oval
     *    @param w the width of the oval
     *    @param h the height of the oval
     */
    public void addOval(Color acolor, int x, int y, int w, int h) {
        Graphics g = this.getBufferedImage().getGraphics();
        g.setColor(acolor);
        g.drawOval(x - SimplePicture._PictureIndexOffset,y - SimplePicture._PictureIndexOffset,w,h);
    }

    /**
     * Method to draw a solid arc on a picture
     *    @param acolor the color of the arc
     *    @param x the x-coordinate of the center of the arc
     *    @param y the y-coordinate of the center of the arc
     *    @param w the width of the arc
     *    @param h the height of the arc
     *    @param start the starting angle at which to draw the arc
     *    @param angle the angle of the arc, relative to the start angle
     */
    public void addArcFilled(Color acolor, int x, int y,
    int w, int h, int start, int angle) {

        Graphics g = this.getBufferedImage().getGraphics();
        g.setColor(acolor);
        g.fillArc(x - SimplePicture._PictureIndexOffset,y - SimplePicture._PictureIndexOffset,w,h,start,angle);
    }

    /**
     * Method to draw the outline of an arc on a picture
     *    @param acolor the color of the arc
     *    @param x the x-coordinate of the center of the arc
     *    @param y the y-coordinate of the center of the arc
     *    @param w the width of the arc
     *    @param h the height of the arc
     *    @param start the starting angle at which to draw the arc
     *    @param angle the angle of the arc, relative to the start angle
     */
    public void addArc(Color acolor,int x, int y, int w, int h, int start, int angle) {
        Graphics g = this.getBufferedImage().getGraphics();
        g.setColor(acolor);
        g.drawArc(x - SimplePicture._PictureIndexOffset,y - SimplePicture._PictureIndexOffset,w,h,start,angle);
    }

    /**
     * Copies all the pixels from this picture to the destination picture,
     * starting with the specified upper-left corner.  If this picture
     * will not fit in the destination starting at the upper-left corner,
     * then only the pixels that will fit are copied.  If the specified
     * upper-left corner is not in the bounds of the destination picture,
     * no pixels are copied.
     * @param dest the picture which to copy into
     * @param upperLeftX the x-coord for the upper-left corner
     * @param upperLeftY the y-coord for the upper-left corner
     */
    public void copyInto(Picture dest, int upperLeftX, int upperLeftY)
    {
    	// Determine the actual dimensions to copy; might be less than
    	// dimensions of this picture if there is not enough space in the
    	// destination picture.
    	int width = this.getWidth();
    	int widthAvailable = dest.getWidth()-upperLeftX;
    	if (widthAvailable < width)
    		width = widthAvailable;
    	int height = this.getHeight();
    	int heightAvailable = dest.getHeight()-upperLeftY;
    	if (heightAvailable < height)
    		height = heightAvailable;

    	// Copy pixel values from this picture to the destination
    	//  (Should have been implemented with the 7-parameter
    	//   getRGB/setRGB methods from BufferedImage?)
    	for (int x = 0; x < width; x++)
    		for (int y = 0; y < height; y++)
    			dest.setBasicPixel(upperLeftX + x, upperLeftY + y, this.getBasicPixel(x, y));

    }

    /**
     * Returns a cropped version of this picture: copies the pixels in
     * it starting at the specified upper-left corner and taking as
     * many pixels as specified by <code>width</code> and <code>height</code>.
     * The final cropped picture may be smaller than indicated by the
     * parameters if the cropping area as specified would go beyond the
     * bounds of this picture.  The cropping area will be <code>0 x 0</code>
     * if the specified upper-left corner is not in the bounds of the
     * destination picture.
     * @param upperLeftX the x-coord of the upper-left corner
     * @param upperLeftY the y-coord of the upper-left corner
     * @param width the desired width of the cropped area
     * @param height the desired height of the cropped area
     * @return the new cropped picture
     */
    public Picture crop(int upperLeftX, int upperLeftY, int width, int height)
    {
    	int widthAvailable = getWidth()-upperLeftX;
   		if (widthAvailable < width)
   			width = widthAvailable;
   		int heightAvailable = getHeight()-upperLeftY;
   		if (heightAvailable < height)
   			height = heightAvailable;

   		Picture newPic = new Picture(width, height);
   		for (int sourceX = upperLeftX, destX = 0; destX < width; sourceX++, destX++)
   			for (int sourceY = upperLeftY, destY = 0; destY < height; sourceY++, destY++)
   				newPic.setBasicPixel(destX, destY, this.getBasicPixel(sourceX, sourceY));
   		return newPic;

    }
} // end of class Picture, put all new methods before this

Edited by Dogstopper: Added spoiler tags to the 6000+ lines of code.

This post has been edited by Dogstopper: 17 December 2010 - 08:38 PM

[RUFerret]

Alright, I implemented what you showed me for the sepia actionlistener, and I'm getting this error: (along with the static errors)

photo.java:90: java.awt.event.ActionListener is abstract; cannot be instantiated

sepia.addActionListener(new ActionListener());

[mufasa]

that's a little much to post (the Picture class isn't all of that). so wait, what issues are you having with your code now?

[RUFerret]

Yeah it's a huge program the Picture class

Here's what I have now.

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import java.util.*;
public class photo implements ActionListener
{
	public JButton bw;
	public JButton neg;
	public JButton sepia;
	public JButton original;
	public Picture photo = new Picture();
	public String file = "peter.jpg";
	public Pixel[] array = photo.getPixels();
	public photo function = new photo();
	public static void main(String[] args)
	{
		Scanner scan = new Scanner(System.in);
		photo.load(file);
		
		JFrame gui = new JFrame("Photo Manipulation");
		gui.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		JPanel buttons = new JPanel();
		buttons.setLayout(new GridLayout(2,2));
		JButton bw = new JButton();
		bw.setText("Black and White");
		buttons.add(bw);
		JButton neg = new JButton();
		neg.setText("Negative");
		buttons.add(neg);
		JButton sepia = new JButton();
		sepia.setText("Sepia");
		buttons.add(sepia);
		JButton original = new JButton();
		original.setText("Original");
		buttons.add(original);
		
		gui.getContentPane().add(buttons);
		gui.pack();
		gui.setVisible(true);
	}
	public void actionPerformed(ActionEvent event)
	{
		if (event.getSource() == bw)
		{	
			bw.addActionListener(new ActionListener() 
			{
				public void actionPerformed(ActionEvent event)
				{
					Picture temp = new Picture();
					temp.load(file);
					Pixel[] temparray = temp.getPixels();
					for (int i = 0; i<array.length; i++)
					{
						int r = temparray[i].getRed();
						int g = temparray[i].getGreen();
						int b = temparray[i].getBlue();
						int w = (r+b+g)/3;
						temparray[i].setRed(w);
						temparray[i].setGreen(w);
						temparray[i].setBlue(w);
					}
					temp.show();
				}
			});
		}
		else if (event.getSource() == neg)
		{
			neg.addActionListener(new ActionListener()
			{
				public void actionPerformed(ActionEvent event)
				{
					Picture temp = new Picture();
					temp.load(file);
					Pixel[] temparray = temp.getPixels();
					for (int i = 0; i<array.length; i++)
					{
						int r = temparray[i].getRed();
						int g = temparray[i].getGreen();
						int b = temparray[i].getBlue();
						r=255-r;
						g=255-g;
						b=255-b;
						temparray[i].setRed(r);
						temparray[i].setGreen(g);
						temparray[i].setBlue(B)/>;
					}
					temp.show();
				}
			});
		}
		else if (event.getSource() == sepia)
		{
			sepia.addActionListener(new ActionListener() 
			{
				public void actionPerformed(ActionEvent event)
				{
					Picture temp = new Picture();
					temp.load(file);
					Pixel[] temparray = temp.getPixels();
					for (int i = 0; i<array.length; i++)
					{
						int r = temparray[i].getRed();
						int g = temparray[i].getGreen();
						int b = temparray[i].getBlue();
						r=255-r;
						g=255-g;
						b=255-b;
						temparray[i].setRed(r);
						temparray[i].setGreen(g);
						temparray[i].setBlue(B)/>;
					}
					temp.show();
				}
			});
		}
		else if (event.getSource() == original)
		{
			photo.show();
		}
	}
}

I'm getting :


C:\Users\Jordan\JavaDocs\Gooey>javac photo.java
photo.java:18: non-static variable file cannot be referenced from a static conte
xt
photo.load(file);
^
photo.java:18: non-static variable photo cannot be referenced from a static cont
ext
photo.load(file);
^
2 errors

[Dogstopper]

If your classes followed convention, you would have realized that photo is a class. Classes should start with a capital letter and have every other word capitalized too. Like this:
MyClass
Photo
...

However, you have this line:

photo.load(file);

photo is a class. Use the photo object that you called function.

function.load(file);

Also, we are not going to help you patch together a 6000+ line program with parts taken from other sources. We are willing to help certainly, but 6000 lines is just too much!

Edit: Also look at your imports....you have MANY that are the exact same...

This post has been edited by Dogstopper: 17 December 2010 - 08:39 PM

[RUFerret]

Nononono, Picture.java is just so I can use it to manipulate the picture. like.. getPixels() and whatnot.

I'm just trying to get the GUI together. lol

and photo function = new photo(); was there so I can use functions in the same file, it's gone now, because I am not calling functions anymore.

This static error is what's going wrong.

when I use photo.load(file); it's using the Picture class method to load the image, to be used (my itec professor made us do a lab on this, so it's all i know. I'm simply turning our command loop manipulator into a GUI)

[Dogstopper]

Nonetheless, that's where the error is located. Look at the error:
photo.java:18: non-static variable file cannot be referenced from a static conte
xt
photo.load(file);


That is saying that load() can only be accessed through an object, not a class. If you don't need it at the moment either comment it out, fix it, or delete it.