Paint

[AKEEL MALIK]

Hi,
Ive created an applet in java for which displays images on a canvas, it also has panels for the buttons and components. I have used the paint method for displaying the images. The problem I'm haveing is that when I run the applet the panels are painted over, such that only the buttons are visible but the panels borders are just painted over.

  
//package m;
//C:\Sun\AppServer\jdk\bin\appletviewer.exe -J-Djava.security.policy=java.policy MorphApplet.htm
/**
 *Mohammed Akeel Malik
 *
 **/
 
///////////////////////////////////////
// LINES 395-412 AND LINE 485 HAVE   // 
// HAVE BEEN SAMPLED & MODIFIED FROM // 
// LaxmiNarayana kotas WORK of Tweening           
///////////////////////////////////////
 
/////////////// IMPORTS ///////////////
import java.io.*;                    //
import java.awt.*;                   //
import java.util.*; //
import java.applet.*;                //
import javax.swing.*;                //
import java.awt.image.*;             //
import java.awt.event.*;             //
import javax.swing.filechooser.FileFilter;    //
import java.awt.image.ImageObserver; //
///////////////////////////////////////
 

public class Morph2 extends JApplet implements Runnable, ActionListener
{
 

//container
    private Container contentPane;
//gridbaglayout
    private GridBagLayout panelLayout;
private GridBagConstraints panelConstraints;

private Dimension panelSize;
    
///////// GUI COMPONENTS /////////////
 
  public JPanel p   = new JPanel();
public JPanel buttonPanel = new JPanel();
  public JPanel menuPanel   = new JPanel();
 

private Button go        = new Button(" GO! ");
private Button start     = new Button("Start");
private Button stop      = new Button("Stop ");
private Button reset     = new Button("Reset");
private Button quit      = new Button(" Quit ");
private Button buttons[] = new Button[6];

private Choice option    = new Choice();

private String choices[] = 
{"    2  ", "    3  ", "    4  ", "    5  ", "    6  " };

//==========textfiled for status panel==================================
private JPanel statusPanel;
private JTextField date;
private GregorianCalendar calendar;

//============the static colours that are used all around the gui
static Color font   = new Color (85,85,164);
static Color button = new Color (235,226,217);
static Color lbg    = new Color (158,168,223);
 
//===========================================
 
  static int frameWeight = 1;
  boolean isStandalone = false;
 
  int cnt  = 0; // USED AS COUNTERS 
  int cnt1 = 0;
 

//============Canvas()==========  
  private JPanel   imageCanvas = new JPanel();
private JPanel i = new JPanel();
  
  Thread t;
  Image img[],img1;
  
  Image ims[];
  
  MediaTracker med;
  PixelGrabber pg[];
  
  Image    offScreenImage;
  Graphics offScrGc;
  
  String imagenames[];// STORE FOR THE APPLET PARAMETERS
  String author;
 
  int pictureTotal, temp, max, delay = 0;// STORE PARAMETERS FROM APPLET
 
  int pixels[], clear[], clearbuf[], bufimg[][];
 
  int imageWidth = 0,  imageHeight = 0;
  int topCount   = 0,  bottomCount = 0;
 
  int leftSourceCount = 0, rightSourceCount = 0;
  int leftTargetCount = 0, rightTargetCount = 0;
 
  int leftSourceMargin [],  rightSourceMargin [];
  int leftTargetMargin [],  rightTargetMargin [];
 
  int topSourceMargin = 0,  bottomSourceMargin = 0;
  int topTargetMargin = 0,  bottomTargetMargin = 0;
 
  int tempDif = 0;
  int sourceWidthDif  = 0,  targetWidthDif  = 0, totalXDif = 0, xIncrement = 0;
  int sourceHeightDif = 0,  targetHeightDif = 0, totalYDif = 0, yIncrement = 0;
 
//===============JFileChooser declaration
  private JFileChooser FileChoose;
  private String[] java = new String[] {"java"};
private String[] html = new String[] {"html","shtml"};
private String[] images = new String[] {"gif","jpg","jpeg"};
//======================================================================
  
  private File file[] = new File[6];// USED TO STORE IMAGE FILES SELECTED
  // BY THE USER VIA THE JFileChooser  
  
  private String location0;
  private String location1;
  private String location2;// STRING REPRESENTATIONS OF THE IMAGES FILE
  private String location3;// USD TO CREATE NEW IMAGES FROM LOCAITON
  private String location4;// AND ADD THEM TO THE ARRAY OF IMAGE MORPHS
  private String location5;
 
  private int buttonCounter = 0;// USED TO DISPLAY CORRECT AMOUNT OF BUTTONS
  // & ONLY ENABLE THEM IN ORDER
  
  int num = 0;// REPRESENTS THE NUMBER OF IMAGES SELECTED 
  // BY THE USER VIA THE Choice BOX
 
  
 
/*******************Get parameters from html file******************************/
 
  public String getParameter(String key, String def)
  {
    return isStandalone ? System.getProperty(key, def) :
      (getParameter(key) != null ? getParameter(key) : def);
  }
 
/******************************************************************************/
 
  public void init()
  {
//==============================================================================
contentPane = getContentPane(); 
contentPane.setLayout(new BorderLayout(30,30));
 
//===========filechooser
FileChoose = new JFileChooser ();
//===========only allow one file to be selected
FileChoose.setMultiSelectionEnabled(false);
//===========files that will be filtered to
FileChoose.addChoosableFileFilter (new SimpleFileFilter(html, 
                                       "Html Files (*.html, *.htm, *.shtml)"));                                      
    FileChoose.addChoosableFileFilter (new SimpleFileFilter(java, 
                                       "Java Files (*.java)"));  
    FileChoose.addChoosableFileFilter (new SimpleFileFilter(images, 
                                       "Picture Files (*.gif, *.jpg, *.jpeg)"));
                                       
//==========Add components panels and components================================
 
    p.setPreferredSize(panelSize); // panel Size
    p.setBorder(BorderFactory.createTitledBorder("Create"));
p.setBackground(font); 

contentPane.add(p,"North");
 
//==========add choice comp's to panel p========
//addComponent(p,option,2,1,1,1,1,0);
/*****/p.add(go);
//addComponent(p,go,2,2,1,1,1,0);
go.addActionListener(this);
/*****/p.add(quit);
quit.addActionListener(this);

//=========Drawing Area=========================================================

imageCanvas.setBackground(lbg); 
contentPane.add(imageCanvas, "Center");
 
//===== Creates the status panel ===============================================

statusPanel=new JPanel();
statusPanel.setBorder(BorderFactory.createTitledBorder("DATE PANEL"));
statusPanel.setLayout(new BorderLayout());
date = new JTextField(10);
date.setForeground(font); // this changes the font colour to the one staticly specified above
date.setFont(new Font("Tahoma", Font.BOLD, 12 ));
date.setHorizontalAlignment(JTextField.CENTER);
date.setToolTipText( "Todays Date" );
todaysDate();
statusPanel.add(date, BorderLayout.EAST);
JLabel lGroup=new JLabel("Final Year Project V2.5 ");
statusPanel.add(lGroup, BorderLayout.WEST); 

contentPane.add(statusPanel, "South");
//==============================================================================
    
    // READ IN THE PARAMETERS (SPEC) FROM THE APPLET SOURCE
    try{
        pictureTotal  = Integer.parseInt(  getParameter(  "pictureTotal","0" ));
        max           = Integer.parseInt(  getParameter( "fadecount","30" ));
        delay         = Integer.parseInt(  getParameter( "delay","30" ));
        author        = this.getParameter( "author", "" );
    }catch(Exception exce){}
 
//->
    
    // CREATE ARRAY OF IMAGES & IMAGE NAMES, AND THEN ASSIGN THE NAMES TO IMAGES
    
//    this.setBackground(new Color(Integer.parseInt(bgcolor.substring(2),16)));
    
 
    img = new Image[pictureTotal];
        
    imagenames = new String[pictureTotal];
 
    
    if(pictureTotal > 0 )
    {
      try{                 
           for( int i=0; i < pictureTotal; i++ )                      
            imagenames[i]=getParameter("imagenames[" + i + "]", "");
           
 
         }catch(Exception exce){}
    }
 
   
    for( int i = 0 ; i < pictureTotal; i++ )
      img[i] = getImage( getCodeBase(), imagenames[i] );
     
    location0 = imagenames[0];
    location1 = imagenames[1];

 
  //REGISTER ALL THE IMAGES WITH A MediaTracker
  med = new MediaTracker(this);
  for( int i=0; i<img.length; i++ )
    med.addImage(img[i],0);
 

// SET UP THE CHOICE DROP DOWN BOX & PANELS ETC
 
for (int i = 0 ; i <choices.length; i++ )
{
option.addItem(choices[i]);
}
 
//==============================================================================

if(!author.equalsIgnoreCase("Adam Butt"))
   System.exit(0);
   
 
    
//==============================================================================
//puts a menubar in application
JMenuBar bar = new JMenuBar();
   setJMenuBar(bar);
   JMenu fileMenu = new JMenu("File");
   fileMenu.setMnemonic('F');
   JMenuItem exit = new JMenuItem("Exit");
   exit.setMnemonic('x');
   exit.addActionListener
   (
    new ActionListener()
    {
        public void actionPerformed( ActionEvent e)
        {
         System.exit(0);      
      }//actionperformed
     }//actionlistener
  );
    fileMenu.add(exit);
    bar.add(fileMenu);
//==============================================================================
 
}//init()
 
/******************************************************************************/
//===== Adds components to panels with gridbag layouts =========================
 
public void addComponent(JPanel p, Component c, int row, int column,int width, int height, int wx, int wy)
{
panelConstraints.gridx=row;
    panelConstraints.gridy=column;
    panelConstraints.gridwidth=width;
    panelConstraints.gridheight=height;
    panelConstraints.weightx=wx;
    panelConstraints.weighty=wy;
    //panelConstraints.fill=GridBagConstraints.BOTH;
    panelConstraints.insets=new Insets(10,10,10,10);
    panelLayout.setConstraints(c, panelConstraints); 
    p.add(c); 
  }//addComponent   
 
/******************************************************************************/
//=====METHOD SETTING THE DATE AND TIME======================================  
public void todaysDate()
{
calendar = new GregorianCalendar();//instance of gregorian calendar
int day, month, year;
day = calendar.get(calendar.DAY_OF_MONTH);//day
month = calendar.get(calendar.MONTH) + 1;//month
year = calendar.get(calendar.YEAR);//year
date.setText(" " +day +" / " +month +" / " +year);//display on the date textfield
}//todaysdate()    
 
/******************************************************************************/
 
  // THREAD CONTROL
 
  public void start()
  { t = new Thread(this); t.start(); }
 
  public void stop()
  { t.interrupt(); }
 
  public void destroy()
  { if(t != null) t = null; }
 
/******************************************************************************/
 
public void run()
  {
     try
 {
       med.waitForID(0);//This method enables tracking and only returns when image has loaded
       //parameter must be 0
       imageWidth  = img[0].getWidth(null);
       imageHeight = img[0].getHeight(null);
 
       // CREATE AN ARRAY TO STORE 'ALL' THE PIXELS
       pixels   = new int[ imageWidth * imageHeight ];
       clearbuf = new int[ imageWidth * imageHeight ];
       clear    = new int[ imageHeight ];
 
       leftSourceMargin  = new int[imageHeight];
       rightSourceMargin = new int[imageHeight];
       leftTargetMargin  = new int[imageHeight];
       rightTargetMargin = new int[imageHeight];
 

       for( int i=0; i < imageHeight; i++ )
        {
         
         for( int j=0; j < imageWidth; j++ )
            {
              pixels[imageWidth*i+j]   = 0xffffff;  // DEFAUL SET ALL TO WHITE
              clearbuf[imageWidth*i+j] = 0xffffff;
            }//for j
// INITIALISE AND SET clear[] TO ZEROS
clear[i]=0;
}//for i

       //No IMAGES & PIXELS FOR EACH IMAGE
         //z  
        bufimg = new int[img.length][imageWidth*imageHeight];
        pg = new PixelGrabber[img.length];
        clear  = new int[imageHeight]; // already done a few lines higher
 
       // ACQUIRE EACH PIXEL
        for( int i = 0; i < img.length; i++ )
        {
        pg[i] = new PixelGrabber( img[i], 0, 0, imageWidth, imageHeight,
         bufimg[i], 0, imageWidth );
         
         pg[i].grabPixels();
        }//for
    }//try
 
    catch (InterruptedException exce)
     {
     getAppletContext().showStatus("Image Failure");
    }
 

 try//(2)
    {
    for(; :wink:          // CONSTANTLY REPEATS DISPLAYING OF IMAGE
    {
      cnt++;
      if(cnt > max) // RESET THE COUNTERS WHEN TARGET IMAGE REACHED
      {
         cnt1++;
         if( cnt1 > img.length-1 )
           cnt1 = 0;
         cnt = 0;
      }//if
 
     temp = (cnt1 < (img.length-1)) ? 1 + cnt1 : 0; 
     topCount = 0;
 
     // THE NEXT FEW MAIN FOR LOOPS LAYOUT THE VIRTUAL MESH APPROPRIATELY OVER 
     // THE SOURCE AND TARGET IMAGES
 
    if( cnt >= 0 && cnt <= 1 ) 
{
      for( int i=0; i < imageHeight; ++i ) // LEFT MARGIN OF SOURCE IMAGE
      {
        leftSourceCount  = 0;
        rightSourceCount = 0;
 
        for( int j = 0; j < frameWeight*imageWidth; ++j )
        {
          if( leftSourceCount == 0 && j > 0 )
          {
            if( filter( bufimg[cnt1] [imageWidth * i + j * imageWidth /
            (frameWeight * imageWidth)], 11) != filter(bufimg[cnt1]
            [imageWidth * i], 11) )
            {
               leftSourceMargin[i] = j / frameWeight;
               leftSourceCount++;
 
               if( topCount == 0 )
               {
                 topSourceMargin = i;
                 topCount++;
               }//if
               else
                 topCount++;
            }//if()
          }//if()
        }//for()
      }//for()
 
     bottomSourceMargin = topCount + topSourceMargin;
     topCount = 0;  
 
     for( int i=0; i < imageHeight; ++i ) // RIGHT MARGIN OF SOURCE IMAGE
     {
      rightSourceCount = 0;
      for( int j = 0; j < frameWeight * imageWidth; ++j )
      {
        if( rightSourceCount == 0 && j < frameWeight * imageWidth )
        {
          if( filter(bufimg[cnt1][imageWidth * i + (frameWeight*imageWidth-1-j)*
          imageWidth/(frameWeight * imageWidth)], 11) != 
          filter(bufimg[cnt1] [imageWidth * i + imageWidth - 1], 11) )
          {
           rightSourceMargin[i] = j/frameWeight;
           rightSourceCount++;
          }//if(0
        }//for()
      }//for()
     }//for()
 
     for( int i=0; i < imageHeight; ++i )  // LEFT MARGIN OF TARGET IMAGE
     {
      leftTargetCount  = 0;
      rightTargetCount = 0;
 
      for( int j = 0; j < frameWeight*imageWidth; ++j)
      {
        if( leftTargetCount == 0 && j > 0 )
        {
          if( filter(bufimg[temp] [imageWidth * i + j * imageWidth / 
          (frameWeight * imageWidth )], 11) != 
          filter( bufimg[temp] [imageWidth*i], 11) )
          {
            leftTargetMargin[i] = j/frameWeight;
            leftTargetCount++;
            if( topCount == 0 )
            {
              topTargetMargin = i;
              topCount++;
            }//if()
            else
              topCount++;
          }//if()
        }//if()
      }//for()
}//for()
 
// BOTTOM MARGIN OF TARGET IMAGE
    bottomTargetMargin=topCount+topTargetMargin;topCount=0; 
 
    for( int i = 0; i < imageHeight; ++i )  // RIGHT MARGIN OF TARGET IMAGE
    {
      rightTargetCount = 0;
    for(int j=0; j<frameWeight*imageWidth; ++j)
      {
        if ( rightTargetCount == 0 && j < frameWeight*imageWidth )
        {
          if( filter( bufimg[temp][imageWidth * i + (frameWeight*imageWidth-1-j)
          * imageWidth / ( frameWeight * imageWidth)], 11) != 
          filter( bufimg[temp] [imageWidth * i + imageWidth - 1], 11) )
          {
            rightTargetMargin[i] = j/frameWeight;
            rightTargetCount++;
          }//if()
        }//if()
      }//for()
    }//for()
}//if( cnt >= 0 && cnt <= 1 )
 

  for( int k = 0; k < imageHeight; ++k )  // HEIGHT
  {
 
    targetHeightDif = bottomTargetMargin - topTargetMargin;
    sourceHeightDif = bottomSourceMargin - topSourceMargin;
 
    // HOW MUCH THE 'HEIGHT' NEEDS TO BE ALTERED DURING THE MORPH
    
    //ration / proportion / percent
    yIncrement = topSourceMargin - (topSourceMargin - topTargetMargin)*cnt/max;  
    
    // ACUTAL DIFFERENCE IN HEIGHT
    totalYDif  = sourceHeightDif - (sourceHeightDif - targetHeightDif)*cnt/max;  
 
    // IF THE TARGET HEIGHT IS NOT YET REACHED (DURING MORPH)
     if( k >= yIncrement && k <= yIncrement + totalYDif )
     {
       for( int j = 0; j < imageWidth; ++j )  //WIDTH
       {
          int scalehsrc, scalehdst;
 
          scalehsrc = topSourceMargin+(k-yIncrement)*sourceHeightDif/totalYDif;
          scalehdst = topTargetMargin+(k-yIncrement)*targetHeightDif/totalYDif;
 
          // ESTABLISH THE 'WIDTH' DIFF'S, NEEDED FOR THE MORPHING OF THE IMAGES
          targetWidthDif = ( imageWidth - 1 - rightTargetMargin[scalehdst]) - 
          leftTargetMargin[scalehdst];
                    
          sourceWidthDif = ( imageWidth - 1 - rightSourceMargin[scalehsrc]) - 
          leftSourceMargin[scalehsrc];
 
          // CALCULATE THE HORIZONTAL MORPH FACTORS (WIDTH)
          totalXDif = leftSourceMargin[scalehsrc] - leftTargetMargin[scalehdst];
          xIncrement = leftSourceMargin[scalehsrc] - totalXDif*(cnt)/max;
 
          tempDif = sourceWidthDif - (sourceWidthDif-targetWidthDif)*(cnt)/max;
 
          // IF GAP SIZE BETWEEN SOURCE & TARGET HASN'T BEEN COMPLETED CONTINUE
          if( j > xIncrement && j <= xIncrement + tempDif )
          {
            int x, x1; // SPECIFIC PIXELS
            
            x  = imageWidth * scalehsrc + leftSourceMargin[scalehsrc] + 
            ( j - xIncrement ) * sourceWidthDif / tempDif; // SOURCE IMAGE
            
            x1 = imageWidth * scalehdst + leftTargetMargin[scalehdst] + 
            ( j - xIncrement ) * targetWidthDif/tempDif;// TARGET IMAGE
            
            pixels[imageWidth * k +j] = 0xff<<24 | (compositefilter(bufimg[cnt1]
            [x], max-cnt) + compositefilter( bufimg[temp] [x1], cnt));           
}//if(j)
          else
            pixels[imageWidth*k+j]=0xff000000;  // SET TO BLACK
        }//for( int j = 0; j < imageWidth; ++j )  //WIDTH
      }//if
    }//for( int k = 0; k < imageHeight; ++k )  // HEIGHT
    
    // CREATE AN INTERMEDIATE IMAGE
    img1 = createImage(new MemoryImageSource
      ( imageWidth,imageHeight,pixels,0,imageWidth ) );
    
   if( cnt == max )
      t.sleep(1000);   // PAUSE WHEN TARGET REACHED
    else
      t.sleep(delay);  // TIME BETWEEN FRAMES (INTERMEDIATE IMAGES)
 
    repaint();
  }//for(; :wink:          // CONSTANTLY REPEATS DISPLAYING OF IMAGE
  }//try(2)
  catch(InterruptedException e)
  {}
}//run
 
/******************************************************************************/
 
  public synchronized void update(Graphics g)
  {
    //Dimension d = getSize();    // SIZE OF THE APPLET WINDOW
 
    // CREATE THE DRAWING AREA
    
      offScreenImage    = createImage(100, 100);
      offScrGc = offScreenImage.getGraphics();
 
 
    //offScrGc.setColor( getBackground(lbg) );  // SET IN APPLET ANYWAY
    offScrGc.fillRect( 100, 100, 100, 100 );
    paint( offScrGc );
    
    //this.setBackground(lbg);
  }//update()
  
/******************************************************************************/
 
public void paint(Graphics g)
  {
  Graphics pCraphics = imageCanvas.getGraphics();
  
   if( med.statusAll(false) == med.COMPLETE )
   {
      pCraphics.drawImage(img1, 100, 100, this);//co-ordinates of where image will be drawn
}
   else
    {
//      pCraphics.setColor( new Color( Integer.parseInt(fontcolor.substring(2),16)) );
      pCraphics.drawString("Loading Images Please Wait...",150,150);
    }
 
}//paint()
/******************************************************************************/
 
public String getAppletInfo()
  {
    return "Morph -  Adam Butt [2003]";
  }
 
/******************************************************************************/
 
  public String[][] getParameterInfo()
  {
    return null;
  }
 
/******************************************************************************/
 

  // COLOUR VALUES [FADE] - PERIMETER OF IMAGE AGAINST BACKGROUND
 
  public int filter(int rgb,int percent)
  {
    int r, g, b, temp;
 
    r = rgb >> 16 & 0xff;
    g = rgb >>  8 & 0xff;
    b = rgb &   0xff;
    r = r*8/100;
    g = g*8/100;
    b = b*8/100;

    return ( 0xff << 24 | r << 16 | g << 8 | b );
  }
 
/******************************************************************************/
 
 public int compositefilter(int rgb, int percent)
 {
int r, g, b;
 
   r = rgb >> 16 & 0xff;
   g = rgb >>  8 & 0xff;
   b = rgb &   0xff;
   r = r*percent / max;
   g = g*percent / max;
   b = b*percent / max;
 
   return ( 0xff << 24 | r << 16 | g << 8 | b );
 }
 
/******************************************************************************/
 
  public void actionPerformed(ActionEvent e)
  {

   if(e.getSource() == go)
   {
  p.setLayout(new GridLayout(2,1));
  num = option.getSelectedIndex() + 1;// NUMBER OF DESIRED IMAGES
  p.removeAll();// CLEAR PANEL p
  
  for(int i = 0; i <= num; i++)// INITIALISE BUTTONS
  {
  buttons[i] = new Button("Image " + (i+1));  
  buttons[i].addActionListener(this);
  buttons[i].setEnabled(false);
  buttonPanel.add(buttons[i]);
  }
    
  buttons[0].setEnabled(true);// SET THESE BUTTONS AVAILABLE
  buttons[1].setEnabled(true);
  buttonCounter = 2;
  
  if(buttonCounter <= num)
  buttons[2].setEnabled(true);
  
   
  start.addActionListener(this);
  stop.addActionListener(this);
  reset.addActionListener(this);
 
menuPanel.add(start);// ADD COMPONENTS TO menuPanel
  menuPanel.add(stop);
  menuPanel.add(reset);
  menuPanel.add(quit);
  
  menuPanel.updateUI();
  menuPanel.revalidate();
  menuPanel.setBackground(Color.black);
  buttonPanel.updateUI();
  buttonPanel.revalidate();  
  buttonPanel.setBackground(Color.black);
  
  p.add(buttonPanel);
  p.add(menuPanel);
  
  p.updateUI();
  p.revalidate(); 
    
  }
//=======================================  
  
   if(e.getSource() == stop)
   {
  stop();// STOP THE THREAD = STOP THE MORPH (PAUSE)
 }
 
//=======================================  
 
 if(e.getSource() == start)
   {
start();// BEGIN MORPHING (OR RESTART MORPHING IF STOPPED)
   }
   
//=======================================  
  
   if(e.getSource() == buttons[0])     
   {
   int returnVal = FileChoose.showOpenDialog(Morph2.this);
      
  if(returnVal == JFileChooser.APPROVE_OPTION)// IF FILE SELECTED
  {
  file[0] = FileChoose.getSelectedFile();// ID THE FILE
  String s = file[0].toString();// REMOVE PATH
  int pos = s.lastIndexOf("\\");  // TO LEAVE FILENAME ONLY
  location0 = s.substring(pos+1);
  
  img[0] = getImage(getCodeBase(), location0); // SET NEW IMAGE FILE
  
  imageWidth = img[0].getWidth(null);
  imageHeight = img[0].getHeight(null);
  stop();
  start();  
  System.out.println(location0);
  }
  
  }
  
//=======================================
  
   if(e.getSource() == buttons[1])
   {       
   int returnVal = FileChoose.showOpenDialog(Morph2.this);
    
  if(returnVal == JFileChooser.APPROVE_OPTION)
  {
  file[1] = FileChoose.getSelectedFile();
  String s = file[1].toString();
  int pos = s.lastIndexOf("\\");
  location1 = s.substring(pos+1);
  
  img[1] = getImage(getCodeBase(), location1); 
  
  imageWidth = img[1].getWidth(null);
  imageHeight = img[1].getHeight(null);
  stop();
  start();
  System.out.println(location1);
  }    
  
   }
   
//=======================================  
  
   if(e.getSource() == buttons[2])// THIRD IMAGE
   {
  int returnVal = FileChoose.showOpenDialog(Morph2.this);
  if(returnVal == JFileChooser.APPROVE_OPTION)
  {
  file[2] = FileChoose.getSelectedFile();
  String s = file[2].toString();
  int pos = s.lastIndexOf("\\");  
  location2 = s.substring(pos+1);
  
  img = new Image[3];// RE-INIT IMG ARRAY
  img[0] = getImage(getCodeBase(), location0); // TO INCREASE SIZE
  img[1] = getImage(getCodeBase(), location1); // & RE-INSERT 
  img[2] = getImage(getCodeBase(), location2); // PREVIOUS IMAGES
  
  imageWidth = img[2].getWidth(null);
  imageHeight= img[2].getHeight(null);
  stop();
  start();
  System.out.println(location2);  
  
  if( buttonCounter < num)// IF MORE FILES WERE DESIRED
  buttons[3].setEnabled(true);// ENABLE THE NEXT BUTTON
  }    
   }
  
//=======================================
 
    if(e.getSource() == buttons[3])// THIRD IMAGE
   {
  int returnVal = FileChoose.showOpenDialog(Morph2.this);
  if(returnVal == JFileChooser.APPROVE_OPTION)
  {
  file[3] = FileChoose.getSelectedFile();
  String s = file[3].toString();
  int pos = s.lastIndexOf("\\");
  location3 = s.substring(pos+1);
  
  img = new Image[4];
  img[0] = getImage(getCodeBase(), location0); 
  img[1] = getImage(getCodeBase(), location1); 
  img[2] = getImage(getCodeBase(), location2); 
  img[3] = getImage(getCodeBase(), location3); 
  
  imageWidth = img[3].getWidth(null);
  imageHeight= img[3].getHeight(null);
  stop();
  start();
  System.out.println(location3);
  
  buttonCounter++;
  
  if( buttonCounter < num )
  buttons[4].setEnabled(true);
  }      
   }
 
//=======================================
 
  if(e.getSource() == buttons[4])
  {
  int returnVal = FileChoose.showOpenDialog(Morph2.this);
  if(returnVal == JFileChooser.APPROVE_OPTION)
  {
  file[4] = FileChoose.getSelectedFile();
  String s = file[4].toString();
  int pos = s.lastIndexOf("\\");
  location4 = s.substring(pos+1);
  
  img = new Image[5];
  img[0] = getImage(getCodeBase(), location0); 
  img[1] = getImage(getCodeBase(), location1); 
  img[2] = getImage(getCodeBase(), location2); 
  img[3] = getImage(getCodeBase(), location3); 
  img[4] = getImage(getCodeBase(), location4); 
  
  imageWidth = img[4].getWidth(null);
  imageHeight= img[4].getHeight(null);
  stop();
  start();
  System.out.println(location4);
  
  buttonCounter++;
  
  if( buttonCounter < num )
  buttons[5].setEnabled(true);
  }    
  }
  
//=======================================
  
  if(e.getSource() == buttons[5])
  {
  int returnVal = FileChoose.showOpenDialog(Morph2.this);
  if(returnVal == JFileChooser.APPROVE_OPTION)
  {
  file[5] = FileChoose.getSelectedFile();
  String s = file[5].toString();
  int pos = s.lastIndexOf("\\");
  location5 = s.substring(pos+1);
  
  img = new Image[6];
  img[0] = getImage(getCodeBase(), location0); 
  img[1] = getImage(getCodeBase(), location1); 
  img[2] = getImage(getCodeBase(), location2); 
  img[3] = getImage(getCodeBase(), location3); 
  img[4] = getImage(getCodeBase(), location4); 
  img[5] = getImage(getCodeBase(), location5); 
  
  imageWidth = img[5].getWidth(null);
  imageHeight= img[5].getHeight(null);
  stop();
  start();
  System.out.println(location5);
  
  buttonCounter++;
  
  if( buttonCounter < num )
  buttons[6].setEnabled(true);
  }    
  } 
  
//=======================================

 if(e.getSource() == reset)
 {
img = new Image[pictureTotal];// RESET IMG ARRAY TO ORIGINAL INIT
location0 = imagenames[0];// SET IMAGES TO THE DEAULTS
    location1 = imagenames[1];
    
    img[0] = getImage(getCodeBase(), location0); 
  img[1] = getImage(getCodeBase(), location1); 
  
  imageWidth = img[1].getWidth(null);
  imageHeight= img[1].getHeight(null);
  
  stop();
  start();  

buttonPanel.removeAll();// RESET ALL PANELS AND VALUES TO DEFAULT
  
  buttonCounter = 2;  
  
  p.setLayout(panelLayout);
  p.removeAll(); 
  //p.add(option);
  addComponent(p,option,2,1,1,1,1,0);
p.add(go);
p.add(quit);

getContentPane().add(p,"North");
p.updateUI();
  p.revalidate();  
  
  System.out.println("Reset");
 }
 
//=======================================
    
    if(e.getSource() == quit)
    {   
   System.exit(0);     
    }
//=======================================
 
} // actionPerformed()
 
} 

[AKEEL MALIK]

I've put this post up in the wrong section it was meant to be in th intermediate section.
Can the administrators move this question.

[Sean Magee]

I do not think this is supposed to be in the intermediate forum, but the GUI one.

You may find answers there
[ March 06, 2005: Message edited by: Sean Magee ]