Sorry for thee length but i have seven classes for this program.
I took several functions and modified them to create a gui interface. I created a JFrame with 4 tabs that contain text only, then i have a 5th tab that has functional JButtons that when selected should prompt the user for input. Inside this 5th tab everything is formatted using a border layout. The jbuttons allows a list to be modified in specific ways. The list will display in a grid format in this tab as well. I think the problem is that Java has no idea where to display the user input boxes because i'm using the border layout???
Right now i'm just trying to get the main buttons to work, before i add in the remaining buttons,

any help would be GREATLY appreciated - i've been trying to figure this out for days

import javax.swing.*;

public class TunesLayout
{

//create a frame that contains a 3 tabbed pane.  

	public static void main (String[] args)

	{
		JFrame frame = new JFrame ("The Java Jukebox");
		frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
		
		JTabbedPane tp = new JTabbedPane();
		tp.addTab ("About", new AboutPanel());
		tp.addTab ("Feedback", new FeedbackPanel());
		tp.addTab ("Donate", new DonatePanel());
		tp.addTab ("Jukebox", new JukeboxPanel());
		
		frame.getContentPane().add(tp);
		frame.pack();
		frame.setVisible(true);
	}
}
import java.awt.*;
 import javax.swing.*;
 
 public class AboutPanel extends JPanel
 { 
 
 //define the panel and its labels
 
 	public AboutPanel()
	{
 		Color color = new Color(245,222,179);
		setBackground (color);
	
		JLabel l1 = new JLabel ("Welcome to the beta version of the Java Jukebox.");
		JLabel l2 = new JLabel ("Choose the Feedback tab to find out how to contact me. " +
											"Your comments are appreciated.");
		JLabel l3 = new JLabel ("Choose the Donate tab to find out how to contribute to the cause.");
		JLabel l4 = new JLabel ("Choose the Jukebox tab to find out about our cd collection.");
	
		add (l1);
		add (l2);
		add (l3);
		add (l4);
	
	}
}
import java.awt.*;
 import javax.swing.*;
 
 public class DonatePanel extends JPanel
 { 
 
 //define the panel and its labels
 
 	public DonatePanel()
	{
 		Color color = new Color(250,128,114);
		setBackground (color);
	
		JLabel l1 = new JLabel ("Hey! We're just struggling students trying to start a business.");
		JLabel l2 = new JLabel ("We need cash to stay afloat. Send money ASAP to:");
		JLabel l3 = new JLabel ("911 Java Lane, Syracuse, NY 13202.");
		JLabel l4 = new JLabel ("The staff of one at Java Jukebox thanks you for your generosity.");
	
		add (l1);
		add (l2);
		add (l3);
		add (l4);
	
	}
}
import java.awt.*;
 import javax.swing.*;
 
 public class FeedbackPanel extends JPanel
 { 
 
 //define the panel and its labels
 
 	public FeedbackPanel()
	{
 		Color color = new Color(255,239,213);
		setBackground (color);
	
		JLabel l1 = new JLabel ("We'd love to know what you think of our product.");
		JLabel l2 = new JLabel ("If you like our product email us at loveJB@hotmail.com.");
		JLabel l3 = new JLabel ("If you don't like us please reference the DONATE tab for instructions");
		JLabel l4 = new JLabel ("Maybe if you donate a little cash we can make it better.");
	
		add (l1);
		add (l2);
		add (l3);
		add (l4);
	
	}
}
import java.awt.*;
 import javax.swing.*;
 import java.awt.event.*;
 import javax.swing.table.DefaultTableModel;
 
 public class JukeboxPanel extends JPanel
 { 
 	JLabel lTitle;
	JButton addCD, delCD, updCD, artistSort, titleSort, searchCD, readFileCD, writeFileCD, appendFileCD;
	JTable table;
	JScrollPane scrollPane;
	CDCollection music; 
 
 //define the panel and its labels
 
 	public JukeboxPanel()
	{

		ActionListener listener = new buttonListener();

 		Color color = new Color(220,220,220);
		setBackground (color);
	
	//adding elements to the jpanel; title and buttons
		JLabel lTitle = new JLabel ("THE JAVA JUKEBOX");
		JButton addCD = new JButton ("Add a CD");
		JButton updCD = new JButton ("Modify a CD");
		JButton delCD = new JButton ("Delete a CD");
		JButton titleSort = new JButton ("Sort by Title");
		JButton artistSort = new JButton ("Sort by Artist");
		
	//location for elements
		add (lTitle, BorderLayout.NORTH);
		add (addCD, BorderLayout.SOUTH);
		add (updCD, BorderLayout.SOUTH);
		add (delCD, BorderLayout.SOUTH);
		add (titleSort, BorderLayout.SOUTH);
		add (artistSort, BorderLayout.SOUTH);
	
	//listener
		addCD.addActionListener(listener);
		updCD.addActionListener(listener);
		delCD.addActionListener(listener);
		titleSort.addActionListener(listener);
		artistSort.addActionListener(listener);
		
		music = new CDCollection();
	
	
	//---------------------
	 // Create the Jtable
        table = new JTable()
        {
            public boolean isCellEditable(int row, int column)
	         {
		         return false;
	         }
        };
        
        table.setPreferredScrollableViewportSize(new Dimension(700, 200));
        table.setFillsViewportHeight(true);
        table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        
        //Create the scroll pane and add the table to it.
        scrollPane = new JScrollPane(table);

        //Add the scroll pane to this panel.
        add(scrollPane, BorderLayout.CENTER);

    }
    
   private class buttonListener implements ActionListener
   {
      //--------------------------------------------------------------
      //  Performs the conversion when the enter key is pressed in
      //  the text field.
      //--------------------------------------------------------------
      public void actionPerformed (ActionEvent event)
      {

         String title = null, artist = null, tracks = null, value = null;
         String[] selection = new String[4];
         CD found = new CD();
         int row = table.getSelectedRow();
			Object source = event.getSource();
         int flag = 0;
         Object[][] data;
			
			// These functions only work if there is a selection
         if (row != -1)
         {
				// Get the selection data
				selection[0] = table.getModel().getValueAt(row, 0).toString();
				selection[1] = table.getModel().getValueAt(row, 1).toString();
				selection[2] = table.getModel().getValueAt(row, 2).toString();
				selection[3] = table.getModel().getValueAt(row, 3).toString();
				if (source == delCD)
				{
					music.delCD(selection[2]);
				}
				else if (source == updCD)
				{
			      title = JOptionPane.showInputDialog ("Enter the title: ", selection[2]);
               if (title != null)
			         artist = JOptionPane.showInputDialog ("Enter the artist: ", selection[3]);
                  if (artist != null)
			            value = JOptionPane.showInputDialog ("Enter the price: ", selection[0]);
                     if (value != null)
			    				 tracks = JOptionPane.showInputDialog ("Enter the number of tracks: ", selection[1]);
           				      if (tracks != null)
                      music.updCD (selection[2], title, artist, Double.parseDouble(value), Integer.parseInt(tracks));
				}
         }
         
         // These functions don't need a selection
			if (source == addCD)
			{
			   title = JOptionPane.showInputDialog ("Enter the title: ");
            if (title != null)
			      artist = JOptionPane.showInputDialog ("Enter the artist: ");
               if (artist != null)
			         value = JOptionPane.showInputDialog ("Enter the price: ");
                  if (value != null)
					        tracks = JOptionPane.showInputDialog ("Enter the number of tracks: ");
		                     if (tracks != null)
		                     music.addCD (title, artist, Double.parseDouble(value), Integer.parseInt(tracks));



			}
			else if (source == titleSort)
			{
				music.sortByTitle();
			}
			else if (source == artistSort)
			{
				music.sortByArtist();
			}
			else if (source == searchCD)
			{
				title = JOptionPane.showInputDialog ("Enter the name of the CD: ");
            
            if (title.equals(""))
               System.out.println("Search failed");
            else
               found = music.binarySearch(title);
               if (found != null)
                  flag = 1;
               else
                  JOptionPane.showMessageDialog (null, "Sorry, we don't have that one.");
			}
			else if (source == readFileCD)
			{
				music.readFile();
			}
			else if (source == writeFileCD)
			{
				music.writeToFile(false);
			}
			else if (source == appendFileCD)
			{
				music.writeToFile(true);
			}
			
         // This refreshes the table by updating the TableModel
         if (flag == 1)
         {
            data = new Object[1][4];	
            data[0][0] = found.getValue();
            data[0][1] = found.getTracks();
            data[0][2] = found.getTitle();	
            data[0][3] = found.getArtist();  
         }
         else
         {
            data = music.getArray();
         }
       
		 		String[] columnNames = {"Price", "Title", "Artist"}; 
		   
//MODIFY			String[] columnNames = {"Price", "# Tracks", "Title", "Artist"};
         DefaultTableModel model = new DefaultTableModel(data, columnNames);
         table.setModel(model);
         
      }
   }

}
import java.text.NumberFormat;
import java.io.*;
import java.util.StringTokenizer;

public class CDCollection
{
   private CD[] collection;
   private int count;
   private double totalValue;
   private int currentSize;

   //-----------------------------------------------------------------
   //  Constructor: Creates an initially empty collection.
   //-----------------------------------------------------------------
   public CDCollection ()
   {
      currentSize = 100;
      collection = new CD[currentSize];
      count = 0;
      totalValue = 0.0;
   }

   //-----------------------------------------------------------------
   //  Adds a CD to the collection, increasing the size of the
   //  collection if necessary.
   //-----------------------------------------------------------------
   public void addCD (String title, String artist, double value, int tracks)
   {
      if (count == currentSize)
         increaseSize();

      collection[count] = new CD (title, artist, value, tracks);
      totalValue += value;
      count++;
   }

   //-----------------------------------------------------------------
   //  Returns a report describing the CD collection.
   //-----------------------------------------------------------------
   public String toString()
   {
      NumberFormat fmt = NumberFormat.getCurrencyInstance();

      String report = "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
      report += "My CD Collection\n\n";

      report += "Number of CDs: " + count + "\n";
      report += "Total cost: " + fmt.format(totalValue) + "\n";
      report += "Average cost: " + fmt.format(totalValue/count);

      report += "\n\nCD List:\n\n";

      for (int cd = 0; cd < count; cd++)
         report += collection[cd].toString() + "\n";

      return report;
   }
	
   //-----------------------------------------------------------------
   //  Deletes a CD from the collection
   //-----------------------------------------------------------------
   public void delCD(String title)
   {
      // j will count the number of CD's in the newly sized collection
      int j = 0;
      // i will count the current number of CD's
      int i;
      // create a temporary array of CD objects 
      // which will become the newly sized collection
      CD [] temp = new CD[currentSize];
       
      for(i=0; i<count; i++)
      {
         // look for a match
         if(title.compareTo(collection[i].getTitle()) != 0)
         {
            // if there is no match, copy from the old to the new
            temp[j] = collection[i];
            j++;
         }
         else
         {  
            // if there is a match, do not copy from the old to the new
            // but update the total value
            totalValue -= collection[i].getValue();
         }
      }
     
      // check to see if there was a match and a deletion from the collection
      if (i != j) 
      {
          count--;
          System.out.println("\nCD deleted\n");
          collection = temp;
      }
      else
          System.out.println("\nCD not found\n");
      
   }
	
	//-----------------------------------------------------------------
   //  Updates a CD from the collection
   //-----------------------------------------------------------------
   
   public void updCD(String oldTitle, String newTitle, String artist, double value, int tracks)
   {
      // i will count the number of CD's in the collection
      int i;
      // flag will tell if a match has been found 
      int flag = 0;  
      // temp will become the new CD collection            
      CD [] temp = new CD[currentSize];
       
      for(i=0; i<count; i++)
      {
         // look for a match
         if(oldTitle.compareTo(collection[i].getTitle()) != 0)
         {
            // if there is no match, copy from the old to the new
            temp[i] = collection[i];
         }
         else
         {
            // if there is a match, replace the current CD 
            // with the updated fields and correct the value
            temp[i] = new CD (newTitle, artist, value, tracks);
            totalValue -= collection[i].getValue();
            totalValue += value;
            // set the flag which indicates a change has happened
            flag = 1;
         }
      }
      
      // check if an update has taken place
      if (flag == 1)
      {
          System.out.println("\nCollection Updated\n");  
          collection = temp;
      }
      else
          System.out.println("\nCD not found\n");
      
   }
	
	//-----------------------------------------------------------------
   //  Sorts the CD's by title
   //-----------------------------------------------------------------
	
	public void sortByTitle()
	{
		int i, j;
		CD temp;
		
		for (i = 0; i < count-1; i++)
		{
			for (j = i+1; j < count; j++)
			{
				if (collection[i].getTitle().compareTo(collection[j].getTitle()) > 0)
				{
					temp = collection[i];
					collection[i] = collection[j];
					collection[j] = temp;
				}
			}
		}
	}
   
   //-----------------------------------------------------------------------------
   //  insertion sort used to sort an integer array: a[0] a[1] a[2] a[3] a[4] a[5]
   //-----------------------------------------------------------------------------
   
   public void sortByArtist ()
   {
	
		// Create akey CD
		CD key = new CD();
		
      // Outside loop starts from CD[0] and goes to CD[count-1]
      for (int index = 1; index < count; index++)
      {
         // initialize key as the number in the current outside loop position
         key = collection[index];
         
		 // initialize position as the current outside loop position
		 int position = index;
		 
         // Inside loop moves smaller numbers left and larger ones right
         while (position > 0 && key.getLastName().compareTo(collection[position-1].getLastName()) < 0)
         {
            // replace smaller number on right by larger number on its left
            collection[position] = collection[position-1];
            
            // move back one position 
            position--;
         }
         // after inside loop is complete, place key where it belongs in sequence
         collection[position] = key;
      }
   }
	
   //-----------------------------------------------------------------
   //  Writes CD collection to disk file 
   //  Overlay any existing data
   //  Create a new file if one does not exist and then write to it
   //-----------------------------------------------------------------
              
   public void writeToFile(boolean append)
   {
       // Try to write to a file
       try 
       {
          // create a file writer object called fw which will overlay any existing data
          FileWriter fw = new FileWriter("CDCollection.txt", append);
          
          // create a file buffered writer object called w 
          // in which to place what will be written to the disc
          BufferedWriter w = new BufferedWriter (fw);
          
          // String s will contain one CD
          String s;
          
          for(int i=0; i<count; i++)
          {
              // create a string s composed of fields separated by | character
	          s = "";
              s += collection[i].getTitle() + "|";
              s += collection[i].getArtist() + "|";
              s += collection[i].getValue() + "|";
              s += collection[i].getTracks() + "\r\n";
              // write the string containing one CD object to the write buffer
              w.write (s);
          }
          
          // Transfer a partially filled buffer to the disc
          w.flush();
          // Close the file (also empties the buffer)
          w.close();
          System.out.println("\nWrite to file is complete\n");
       }
       
       // If there is an file IO error, display why it occurred
       catch(IOException e)
       {
          e.printStackTrace();
       }
   }
	
	//-----------------------------------------------------------------
   //  Increases the capacity of the collection by creating a
   //  larger array and copying the existing collection into it.
   //-----------------------------------------------------------------
	
	public void readFile()
   {
       // Try to read a file
       try 
       {
          // create a file read object called fr which will read from a disc file
          FileReader fr = new FileReader("CDCollection.txt");
          // create a file buffered reader object called r 
          // in which to place what is read from the disc 
          BufferedReader r = new BufferedReader (fr);
          // create a StringTokenizer object t to separate the fields of the CD
          StringTokenizer t;
          
          // create the working data items
          String s, title, artist;
          double value;
          int tracks;
          count = 0;
          totalValue =0;
          
          // outside loop to read consecutive CD's until all are read
          while((s=r.readLine()) != null)
          {
             // get first token - title and then the second - artist, etc
             // each separated from the other by the | character
             t = new StringTokenizer(s,"|");
             title = t.nextToken();
             artist = t.nextToken();
             value = Double.parseDouble(t.nextToken());
             tracks = Integer.parseInt(t.nextToken());
             
             // create a CD object composed of the tokens just read
             collection[count] = new CD (title, artist, value, tracks);
             // update the totalValue and count
             totalValue += value;
             count++;
          }
          if (currentSize == 0) 
             currentSize = 100;
          if (count >= currentSize)
             increaseSize(); 
          r.close();
       }
       // If there is an file IO error, display why it occurred
       catch(IOException e)
       {
          e.printStackTrace();
       }
   }  

   //-----------------------------------------------------------------
   //  Use a binary search to find a specific CD
   //-----------------------------------------------------------------
   
    public CD binarySearch(String targetTitle)
    {
        int min=0;                          // lowest position for search range
        int max=count;                      // highest position for search range
        int mid=0;                          // middle position for search range        
        boolean found = false;              // boolean variable tells if title found
		  
		  // Make sure the array is sorted
		  sortByTitle();
        
        //  loop looks for a match or min > max
        while (!found && min <= max)
        {
            // calculate middle position in the range
            mid = (min+max)/2;
            // compare the title entered to the title of the mid position CD
            if(collection[mid].getTitle().compareTo(targetTitle) == 0)
                found = true;               // we have a match - found is true
            else if (collection[mid].getTitle().compareTo(targetTitle) > 0)
                max = mid-1;                // too high, use max 1 lower than mid
            else 
                min = mid+1;                // too low, use min 1 higher than mid
        }
        
        // determine if there was a match
        if (found) return collection[mid];  // if so, return the CD that matches
        else return null;                   // if not, return an empty CD object
   }

   //-----------------------------------------------------------------
   //  Increases the capacity of the collection by creating a
   //  larger array and copying the existing collection into it.
   //-----------------------------------------------------------------
   
   public Object[][] getArray()
   {
        
      Object[][] data = new Object[count][4];
      
      for (int count = 0; count < this.count; count++)
      {
         data[count][0] = collection[count].getValue();
         data[count][1] = collection[count].getTracks();
         data[count][2] = collection[count].getTitle();
         data[count][3] = collection[count].getArtist();
      }
      
      return data;
   }

   //-----------------------------------------------------------------
   //  Increases the capacity of the collection by creating a
   //  larger array and copying the existing collection into it.
   //-----------------------------------------------------------------
	
   private void increaseSize ()
   {
      CD[] temp = new CD[collection.length * 2];

      for (int cd = 0; cd < collection.length; cd++)
         temp[cd] = collection[cd];

      collection = temp;
   }
}
import java.text.NumberFormat;

public class CD
{
   private String title, artist, artistFirstName, artistLastName;
   private double value;
   private int tracks;

   //-----------------------------------------------------------------
   //  Creates a default CD
   //-----------------------------------------------------------------
   public CD ()
   {
      title = "";
      artist = "";
      value = 0.0;
      tracks = 0;
		artistFirstName = "";
		artistLastName = "";
   }

   //-----------------------------------------------------------------
   //  Creates a new CD with the specified information.
   //-----------------------------------------------------------------
   public CD (String name, String singer, double price, int numTracks)
   {
      title = name;
      artist = singer;
      value = price;
      tracks = numTracks;
		int blank = 0;
		for (int j=0; j < artist.length(); j++)
			if (artist.charAt(j) == ' ')
			{
				blank = j;
				break;
			}
		if (blank == 0)
		{
			artistFirstName = "";
			artistLastName = artist;
		}
		else
		{
			artistFirstName = artist.substring(0,blank);
			artistLastName = artist.substring(blank+1,artist.length());
		}
   }

   //-----------------------------------------------------------------
   //  Returns the title of this CD
   //-----------------------------------------------------------------
   public String getTitle()
   {
		return title;
   }

   //-----------------------------------------------------------------
   //  Returns the artist of this CD
   //-----------------------------------------------------------------
   public String getArtist()
   {
		return artist;
   }

   //-----------------------------------------------------------------
   //  Returns the price of this CD
   //-----------------------------------------------------------------
   public double getValue()
   {
		return value;
   }

   //-----------------------------------------------------------------
   //  Returns the number of tracks in this CD
   //-----------------------------------------------------------------
   public int getTracks()
   {
		return tracks;
   }

   //-----------------------------------------------------------------
   //  Returns the artist's first name
   //-----------------------------------------------------------------
   public String getFirstName()
   {
		return artistFirstName;
   }

   //-----------------------------------------------------------------
   //  Returns the artist's last name
   //-----------------------------------------------------------------
   public String getLastName()
   {
		return artistLastName;
   }
	
	//-----------------------------------------------------------------
   //  Sets the name of this CD
   //-----------------------------------------------------------------
   public void setTitle(String name)
   {
		title = name;
   }

   //-----------------------------------------------------------------
   //  Sets the artist of this CD
   //-----------------------------------------------------------------
   public void setArtist(String singer)
   {
		artist = singer;
   }

   //-----------------------------------------------------------------
   //  Sets the price of this CD
   //-----------------------------------------------------------------
   public void getValue(double price)
   {
		value = price;
   }

   //-----------------------------------------------------------------
   //  Sets the number of tracks on this CD
   //-----------------------------------------------------------------
   public void setTracks(int numTracks)
   {
		tracks = numTracks;
   }

   //-----------------------------------------------------------------
   //  Returns a string description of this CD.
   //-----------------------------------------------------------------
   public String toString()
   {
      NumberFormat fmt = NumberFormat.getCurrencyInstance();

      String description;

      description = fmt.format(value) + "\t" + tracks + "\t";
      description += title + "\t" + artist;

      return description;
   }
}

You may have better luck if you added addCD, updCD, delCD, titleSort, and artistSort to a new JPanel and then set the new panel to JukeboxPanel's South region.

This article has been dead for over six months. Start a new discussion instead.