/*
Copyright @ 2003-2004, The Institute for Genomic Research (TIGR).
All rights reserved.
*/

/***************************************************************************
 * Author:  Jianwei(Jerry) Li
 * Name:  ExpressConverter (Version 1.6)
 * Date:  Created: 02/12/2003 and modified:  01/26/2005
 * Descp: A Java class that converts a variety of gene expression data formats
 *        to TIGR tav and mev file formats.
 * 04/02/03: Changed the interface for holding ImaGene conversion.
 * 06/07/04: Changed the interface for holding ArrayVersion conversion.
 * 09/29/04: Added GUI for generic conversion.
 ***************************************************************************/
package org.tigr.microarray.converter;

import com.sun.java.swing.plaf.windows.WindowsLookAndFeel;
import com.sun.java.swing.plaf.motif.MotifLookAndFeel;
import java.awt.*;
import java.awt.event.*;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.*;
import java.util.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.ButtonGroup;
import javax.swing.event.*;
import javax.swing.plaf.metal.MetalLookAndFeel;
import javax.swing.Timer;
import org.tigr.microarray.converter.GenepixMev;
import org.tigr.util.awt.GBA;
import org.tigr.util.*;
import org.tigr.util.FileReading;
import org.tigr.util.io.IOUtil;
import org.tigr.util.io.MyIni;
import org.tigr.util.MadamFileFilter;
import org.tigr.util.LongTextChanger;
import org.tigr.util.ConfirmUsers;

public class ExpressConverter extends JFrame implements InitialWindow{
  private ArrayVersionPanel arrayVersionPL;
  private AgilentPanel aligentPL;
  private CustomerPanel gCustomerPL;
  private Icon gAnnOneIcon, gAnnManyIcon;
  private JButton gAnnBtn;
  private JCheckBox gAnnOneCkbox, gAnnManyCkbox;
  private JMenuItem aboutMI, changeDirMI, changeNameMI, deleteMI, exitMI, gOpenMI;
  private JMenuItem gSaveMI, helpMI, gLoadMI, prefMI, resetMI, gRunMI, stopMI, viewLogMI;
  private Icon browserIcon, deleteIcon, editIcon, gSaveIcon, gOpenIcon;
  private Icon runIcon, stopIcon, clearIcon, viewLogIcon, helpIcon, changeDirIcon;
  private JComboBox outputCB;
  private JPanel basePanel, toolBarPanel, viewPanel, gAnnTypePanel;
  private JButton fileBrowserBtn, changeDirBtn, gOpenBtn, gSaveBtn;
  private JButton deleteBtn;
  private JButton clearBtn;
  private JButton convertBtn;
  private JButton helpBtn;
  private JButton editBtn;
  private JButton viewLogBtn;
  private JButton stopBtn;

  private JMenuBar menuBar;
  private JMenu fileMenu, editMenu, viewMenu, helpMenu, annMenu;
  private JCheckBox	metalViewCkbox, winViewMI, motifViewMI;
  private JToolBar fileToolBar, editToolBar, helpToolBar;
  private JToolBar outSelBar;  // define the type of output files
  private JProgressBar bar;
  private JLabel progLabel, infoLB, outputLB;
  private JTabbedPane inputTP;
  private ConverterLogView logViewWin;
  private BevelBorder flat;
  private ButtonGroup btnGroup, gAnnGroup;

    // variable declare
  public static Image iconPic;
  public static String gSysPath;
  private static Proface proPic, creditWin;
  public static boolean logWinOn;
  public static boolean helpWinOn;
  public static Vector logFileContent;
  public static ProfaceProjector projector;
  public static final int ONE_FILE = 1;
  public static final int ALL_FILES = 2;
  public static final String CUS_HEADER_FILE = "Customer Header File";
  public static final String INIFILE = "docs/convt.ini";
  public static final String MEV_VER = "V4.0";
  public static final String TITLE = "ExpressConveter V.1.7";
  public static String ECH[] = {"ech"};
  public static final int MAC = 1;
  public static int scrWidth;
  public static int scrHeight;
  public static int gOs;         // operation system.

  private final String CUST_FILE = "custFile";
  private final String CUST_LINE = "cfSize";
  private final String MANUAL_NAME = "docs/convthelp.chm";
  private final String ONE_ONE_INFO = "Each mev file has its own ann file.";
  private final String MANY_ONE_INFO = "Many mev files share one ann file.";
  private final String SCREEN_X = "scrWidth";
  private final String SCREEN_Y = "scrHeight";
  private final String SCREEN_FEEL = "scrFeel";
  private final String SCREEN_PREF = "scrPref";
  private final String VERSION = "ver";
  private final String LOC_X = "locX";
  private final String LOC_Y = "locY";
  private final String ONE_ONE = "1";
  private final String MANY_ONE = "2";

  private AgilentMev aligentMevConvt;
  private ArrayVersionMev arrayVersionMevConvt;
  private boolean gDirtyData;
  private CustomerMev gCustMevConvt;
  private TavConverter genepixTavConvt;
  private GenepixMev genepixMevConvt;
  private ImaGeneTav imaGeneTavConvt;
  private ImaGeneMev imaGeneMevConvt;
  private ScanArrayTav scanArrayTavConvt;
  private ScanArrayMev scanArrayMevConvt;
  private TavMev tavMevConvt;
  private MevTav mevTavConvt;
  private Timer cvTimer;
  private int gSelConverter;  // selected converter
  private int gSizeX, gSizeY, gLocX, gLocY;
  private int gAnnType, gFileLine, gScrFeel;
  private int progEnd;
  private int progCounter;
  private int outputType;
  private long startTime, curTime;
  private ProgramRunner runner;
  private GenePixPanel genePixPL;
  private ImaGenePanel imaGenePL;
  private ScanArrayPanel scanArrayPL;
  private TavPanel tavPL;
  private MevPanel mevPL;
  private Vector selectedChAFiles;    // input files for channel 1 to be converted.
  private Vector selectedChBFiles;    // input files for channel 2 to be converted.
  private String gfType[] = {"gpr", "txt"};
  private String gCustType[];
  private String txtType[] = {"txt"};
  private String tavType[] = {"tav"};
  private String mevType[] = {"mev"};
  private String info;
  private String title;
  private String iniFileName;
  private String gUserTypes;
  private String gVer;
  private Vector initFile;

  private final String[] FILE_TYPE = {"tav", "mev"};
  private final int QUIT = -1;
  private final int NO_FILE = 0;
  private final int TAV_OUT = 0;
  private final int MEV_OUT = 1;

  private final int GENEPIX = 0;
  private final int IMAGENE = 1;
  private final int SCANARRAY = 2;
  private final int ARRAYVERSION = 3;
  private final int ALIGENT = 4;
  private final int TAV = 5;
  private final int MEV = 6;
  private final int CUSTOMER = 7;

  public ExpressConverter(){
    this(null);
  }

  public ExpressConverter(String barTitle) {
    if(barTitle != null){
      title = barTitle;
    } else {
      title = TITLE;
    }
    logWinOn = false;
    helpWinOn = false;
    gDirtyData = false;
    info = new String("");
    //iniFileName = gSysPath + INIFILE;
    iniFileName = INIFILE;  // Mac need relative path
    gOs = getOperationSystem(System.getProperty("os.name"));
    logFileContent = new Vector(10, 3);
    selectedChAFiles = new Vector(10, 3);
    selectedChBFiles = new Vector(10, 3);
    flat = new BevelBorder(2);
    outputType = MEV_OUT;
    gAnnType = ONE_FILE;
    runner = new ProgramRunner();

    projector.setInfoText("    Loading configuration information ... ");
    loadConfigInfo(iniFileName);
    projector.setInfoText("    Building GenePix converter ... ");
    genePixPL = new GenePixPanel(this);
    projector.setInfoText("    Building ImaGene converter ... ");
    imaGenePL = new ImaGenePanel(this);
    projector.setInfoText("    Building ScanArray converter ... ");
    scanArrayPL = new ScanArrayPanel(this);
    projector.setInfoText("    Building ArrayVerson Converter ... ");
    arrayVersionPL = new ArrayVersionPanel(this);
    projector.setInfoText("    Building Agilent converter ... ");
    aligentPL = new AgilentPanel(this);
    projector.setInfoText("    Building TAV converter ... ");
    tavPL = new TavPanel(this);
    projector.setInfoText("    Building MAV converter ... ");
    mevPL = new MevPanel(this);
    projector.setInfoText("   Building Customized  converter ... ");
    gCustomerPL = new CustomerPanel(this);

    if(gSizeX == 0 || gSizeY == 0){
      gSizeX = (int) (scrWidth * 0.85);
      gSizeY = (int) (scrHeight * 0.85);
    }

    createGUI();
    adjustToolBar();
    setPreferenceState();
    this.validate();
    logFileContent.add("ExpressConverter started without errors.\n");
  }

  /*****************************************************************************
   * <b>Description:  </b>
   *   changes the border of a button based on movement of mouse.
   * <p><b>Parameter: </b>
   * <br>  btn --- the button that has been trigged.
   ***************************************************************************/
  private void buttonFace(JButton btn){
    btn.addMouseListener(new MouseAdapter () {
      public void mouseEntered(MouseEvent me){
        buttonUp(me);
      }
    });
    btn.addMouseListener(new MouseAdapter () {
      public void mouseExited(MouseEvent me){
        buttonDown(me);
      }
    });
  }

  /****************************************************************************
   * <b>Description: </b>
   *   makes icons flat.
   **************************************************************************/
  private void adjustToolBar(){
    fileBrowserBtn.setBorder(flat);
    gOpenBtn.setBorder(flat);
    gSaveBtn.setBorder(flat);
    convertBtn.setBorder(flat);
    stopBtn.setBorder(flat);
    changeDirBtn.setBorder(flat);
    editBtn.setBorder(flat);
    deleteBtn.setBorder(flat);
    clearBtn.setBorder(flat);
    viewLogBtn.setBorder(flat);
    helpBtn.setBorder(flat);
    gAnnBtn.setBorder(flat);
  }

  /*****************************************************************************
   * <b>Description: </b>
   *    shows the border of a button.
   * <p><b>Parameter: </b>
   * <br> e --- the mouse event.
   ***************************************************************************/
  private void buttonDown(MouseEvent e){
    JButton btn=(JButton)e.getSource();
    if(btn.isEnabled())
      btn.setBorder(new BevelBorder(2));
  }

  /*****************************************************************************
   * <b>Description:  </b>
   *   hides the border of a button.
   * <p><b>Parameter: </b>
   * <br> e --- the mouse event
   ***************************************************************************/
  private void buttonUp(MouseEvent e){
    JButton btn = (JButton)e.getSource();
    if(btn.isEnabled())
      btn.setBorder(new BevelBorder(0));
  }

  /****************************************************************************
   * <b>Description: </b>
   *   change the directory for output files.
   ***************************************************************************/
  private void changeDirectory(){
    File file;
    int result;
    String tempPath;

    JFileChooser fileChooser = new JFileChooser(gSysPath);

    fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
    fileChooser.setMultiSelectionEnabled(false);
    fileChooser.setDialogTitle(TITLE + " -- selecting a directory");
    result = fileChooser.showOpenDialog(this);

    if(result == JFileChooser.CANCEL_OPTION || result < 0){
      return;
    }

    file = fileChooser.getSelectedFile();
    tempPath = file.getPath();
    gSysPath = tempPath;

    if(gSelConverter == GENEPIX){
      genePixPL.editDirectory(tempPath);
    } else if(gSelConverter == IMAGENE){
      imaGenePL.editDirectory(tempPath);
    } else if(gSelConverter == SCANARRAY){
      scanArrayPL.editDirectory(tempPath);
    } else if(gSelConverter == ARRAYVERSION){
      arrayVersionPL.editDirectory(tempPath);
    } else if(gSelConverter == ALIGENT){
      aligentPL.editDirectory(tempPath);
    } else if(gSelConverter == TAV){
      tavPL.editDirectory(tempPath);
    } else if(gSelConverter == MEV){
      mevPL.editDirectory(tempPath);
    } else if(gSelConverter == CUSTOMER){
      gCustomerPL.editDirectory(tempPath);
    }
  }

  /****************************************************************************
   * <b>Description: </b>
   *  updates the intial file.
   ***************************************************************************/
  private void changeInitFile() {
    initFile = MyIni.setValueToFile(initFile, SCREEN_X, "" + gSizeX);
    initFile = MyIni.setValueToFile(initFile, SCREEN_Y, "" + gSizeY);
    initFile = MyIni.setValueToFile(initFile, SCREEN_FEEL, "" + gScrFeel);
    initFile = MyIni.setValueToFile(initFile, SCREEN_PREF, "" + gSelConverter);
    initFile = MyIni.setValueToFile(initFile, LOC_X, "" + gLocX);
    initFile = MyIni.setValueToFile(initFile, LOC_Y, "" +  gLocY);
    initFile = MyIni.setValueToFile(initFile, CUST_FILE, gUserTypes);
    initFile = MyIni.setValueToFile(initFile, CUST_LINE, "" + gFileLine);
  }

  /****************************************************************************
   * <b>Description: </b>
   *    validate the selected files and process the conversion.
   **************************************************************************/
  private void convertFiles(){
    int numOfFiles, i, test;
    String temp = new String("");
    Vector validOutputFiles, deletedFileAddr, outputFileNames;
    boolean wantTest;

    outputFileNames = new Vector();
    if(gSelConverter == GENEPIX){
      outputFileNames = genePixPL.getOutputFileNames();
      selectedChAFiles = genePixPL.getSelectedFiles();
    } else if(gSelConverter == IMAGENE){
      outputFileNames = imaGenePL.getOutputFileNames();
      selectedChAFiles = imaGenePL.getSelectedChAFiles();
      selectedChBFiles = imaGenePL.getSelectedChBFiles();
    } else if(gSelConverter == SCANARRAY){
      outputFileNames = scanArrayPL.getOutputFileNames();
      selectedChAFiles = scanArrayPL.getSelectedFiles();
    } else if(gSelConverter == ARRAYVERSION){
      outputFileNames = arrayVersionPL.getOutputFileNames();
      selectedChAFiles = arrayVersionPL.getSelectedFiles();
    } else if(gSelConverter == ALIGENT){
      outputFileNames = aligentPL.getOutputFileNames();
      selectedChAFiles = aligentPL.getSelectedFiles();
    } else if(gSelConverter == TAV){
      outputFileNames = tavPL.getOutputFileNames();
      selectedChAFiles = tavPL.getSelectedFiles();
    } else if(gSelConverter == MEV){
      outputFileNames = mevPL.getOutputFileNames();
      selectedChAFiles = mevPL.getSelectedFiles();
    } else if(gSelConverter == CUSTOMER){
      if(gCustomerPL.isValidEquation()){
        outputFileNames = gCustomerPL.getOutputFileNames();
        selectedChAFiles = gCustomerPL.getSelectedFiles();
      } else {
        return;
      }
    }

    numOfFiles = outputFileNames.size();
    validOutputFiles = new Vector(numOfFiles, numOfFiles >> 2);
    deletedFileAddr = new Vector(numOfFiles, numOfFiles >> 2);

    wantTest = true;
    for(i=0; i<numOfFiles; i++){
      temp = (String)outputFileNames.elementAt(i);
      test = validFile(temp, wantTest, 0);
      if(test == ONE_FILE){
        wantTest = true;
        validOutputFiles.add(temp);
      } else if(test == ALL_FILES){
        wantTest = false;
        validOutputFiles.add(temp);
      } else if(test == NO_FILE){
        wantTest = true;
        deletedFileAddr.add("" + i);
      } else {
        return;
      }
    }

    numOfFiles = deletedFileAddr.size();
    for(i=0; i<numOfFiles; i++){
      test = Integer.parseInt((String)deletedFileAddr.elementAt(i));
      selectedChAFiles.removeElementAt(test);
      if(gSelConverter == IMAGENE){
        selectedChBFiles.removeElementAt(test);
      }
      outputFileNames.removeElementAt(test);
    }

    if(gSelConverter == GENEPIX){
      genePixPL.changeFileList(selectedChAFiles, outputFileNames);
    } else if(gSelConverter == IMAGENE){
      imaGenePL.changeFileList(selectedChAFiles, selectedChBFiles, outputFileNames);
    } else if(gSelConverter == SCANARRAY){
      scanArrayPL.changeFileList(selectedChAFiles, outputFileNames);
    } else if(gSelConverter == ARRAYVERSION){
      arrayVersionPL.changeFileList(selectedChAFiles, outputFileNames);
    } else if(gSelConverter == ALIGENT){
      aligentPL.changeFileList(selectedChAFiles, outputFileNames);
    } else if(gSelConverter == TAV){
      tavPL.changeFileList(selectedChAFiles, outputFileNames);
    } else if(gSelConverter == MEV){
      mevPL.changeFileList(selectedChAFiles, outputFileNames);
    } else if(gSelConverter == CUSTOMER){
      gCustomerPL.changeFileList(selectedChAFiles, outputFileNames);
    }

    clearBtn.setEnabled(false);
    resetMI.setEnabled(false);
    changeDirBtn.setEnabled(false);
    changeDirMI.setEnabled(false);

    progEnd = 0;
    progCounter = 0;
    bar.setValue(progCounter);
    infoLB.setText("");
    progLabel.setText("");

    if(selectedChAFiles.size() > 0){
      if(outputType == TAV_OUT && gSelConverter == GENEPIX){ // converting to tav files
        genepixTavConvt = new TavConverter(selectedChAFiles, validOutputFiles);
        genepixTavConvt.setSortSpots(genePixPL.wantSort());
        genepixTavConvt.setKeepAllInformation(genePixPL.keepAllInformation());
        cvTimer = new Timer(100, new ConvertListener(genepixTavConvt));
        genepixTavConvt.start();

      } else if(outputType == TAV_OUT && gSelConverter == IMAGENE) {
        imaGeneTavConvt = new ImaGeneTav(this, selectedChAFiles, selectedChBFiles, validOutputFiles);
        imaGeneTavConvt.setSortSpots(imaGenePL.wantSort());
        imaGeneTavConvt.attachGeneId(imaGenePL.needGeneID());
        cvTimer = new Timer(100, new ConvertListener(imaGeneTavConvt));
        imaGeneTavConvt.start();

      } else if(outputType == MEV_OUT && gSelConverter == GENEPIX){
        genepixMevConvt = new GenepixMev(selectedChAFiles, validOutputFiles, TITLE, gAnnType);
        genepixMevConvt.setSortSpots(genePixPL.wantSort());
        genepixMevConvt.setIntensityType(genePixPL.getIntensityType());
        genepixMevConvt.backgroundCorrected(genePixPL.isBackgroundCorrected());
        cvTimer = new Timer(100, new ConvertListener(genepixMevConvt));
        genepixMevConvt.start();

      } else if(outputType == MEV_OUT && gSelConverter == IMAGENE){
        imaGeneMevConvt = new ImaGeneMev(this, selectedChAFiles, selectedChBFiles,
                                         validOutputFiles, TITLE, gAnnType);
        imaGeneMevConvt.setSortSpots(imaGenePL.wantSort());
        imaGeneMevConvt.setIntensityType(imaGenePL.getIntensityType());
        imaGeneMevConvt.backgroundCorrected(imaGenePL.isBackgroundCorrected());
        cvTimer = new Timer(100, new ConvertListener(imaGeneMevConvt));
        imaGeneMevConvt.start();

      } else if(outputType == TAV_OUT && gSelConverter == SCANARRAY){
        scanArrayTavConvt = new ScanArrayTav(this, selectedChAFiles, validOutputFiles,
            scanArrayPL.getQuantiationWay());
        scanArrayTavConvt.setSortSpots(scanArrayPL.wantSort());
        scanArrayTavConvt.setKeepAllInformation(scanArrayPL.keepAllInformation());
        scanArrayTavConvt.setSwapChannel(scanArrayPL.swapOriginalChannel());
        cvTimer = new Timer(100, new ConvertListener(scanArrayTavConvt));
        scanArrayTavConvt.start();

      } else if(outputType == MEV_OUT && gSelConverter == SCANARRAY){
        scanArrayMevConvt = new ScanArrayMev(this, selectedChAFiles, validOutputFiles,
          scanArrayPL.getQuantiationWay(), TITLE, gAnnType);
        scanArrayMevConvt.setSortSpots(scanArrayPL.wantSort());
        scanArrayMevConvt.setIntensityType(scanArrayPL.getIntensityType());
        scanArrayMevConvt.backgroundCorrected(scanArrayPL.isBackgroundCorrected());
        scanArrayMevConvt.needSwapChannels(scanArrayPL.swapOriginalChannel());
        cvTimer = new Timer(100, new ConvertListener(scanArrayMevConvt));
        scanArrayMevConvt.start();

      } else if(outputType == MEV_OUT && gSelConverter == ARRAYVERSION){
        arrayVersionMevConvt = new ArrayVersionMev(selectedChAFiles, validOutputFiles,
          TITLE);
        arrayVersionMevConvt.setSortSpots(arrayVersionPL.wantSort());
        arrayVersionMevConvt.setIntensityType(arrayVersionPL.getIntensityType());
        arrayVersionMevConvt.backgroundCorrected(arrayVersionPL.isBackgroundCorrected());
        cvTimer = new Timer(100, new ConvertListener(arrayVersionMevConvt));
        arrayVersionMevConvt.start();

      } else if(outputType == MEV_OUT && gSelConverter == ALIGENT) {
        aligentMevConvt = new AgilentMev(this, selectedChAFiles, validOutputFiles,
                                         TITLE, gAnnType);
        aligentMevConvt.setSortSpots(aligentPL.wantSort());
        aligentMevConvt.setIntensityType(aligentPL.getIntensityType());
        aligentMevConvt.backgroundCorrected(aligentPL.isBackgroundCorrected());
        cvTimer = new Timer(100, new ConvertListener(aligentMevConvt));
        aligentMevConvt.start();

      } else if(outputType == MEV_OUT && gSelConverter == TAV) {
        tavMevConvt = new TavMev(selectedChAFiles, validOutputFiles, TITLE, gAnnType);
        tavMevConvt.setSortSpots(tavPL.wantSort());
        cvTimer = new Timer(100, new ConvertListener(tavMevConvt));
        tavMevConvt.start();

      } else if(outputType == TAV_OUT && gSelConverter == MEV){
        mevTavConvt = new MevTav(selectedChAFiles, validOutputFiles, TITLE);
        mevTavConvt.setSortSpots(mevPL.wantSort());
        mevTavConvt.setKeepAllInformation(mevPL.keepAllInformation());
        cvTimer = new Timer(100, new ConvertListener(mevTavConvt));
        mevTavConvt.start();

      } else if(outputType == MEV_OUT && gSelConverter == CUSTOMER){
        gCustMevConvt = new CustomerMev(this, selectedChAFiles, validOutputFiles,
          TITLE, gAnnType);
        gCustMevConvt.setSortSpots(gCustomerPL.wantSort());
        gCustMevConvt.setIntensityType(gCustomerPL.getIntensityType());
        gCustMevConvt.setCustomerEquation(gCustomerPL.getConvertEquations());
        gCustMevConvt.setMevHeaders(gCustomerPL.getMevHeaders());
        gCustMevConvt.setInputHeader(gCustomerPL.getInputHeaders());
        gCustMevConvt.setInputHeaderOffset(gCustomerPL.getInputHeaderOffset());
        gCustMevConvt.setSelectedColumnsForAnn(gCustomerPL.getSelecteColumnForAnn());
        cvTimer = new Timer(100, new ConvertListener(gCustMevConvt));
        gCustMevConvt.start();
      }

      startTime = System.currentTimeMillis();
      cvTimer.start();
      convertBtn.setEnabled(false);
      gRunMI.setEnabled(false);
      stopBtn.setEnabled(true);
      stopMI.setEnabled(true);
    }
  }

  /***************************************************************************
   * <b>Description: </b>
   *   change an output file name.
   **************************************************************************/
  private void editFileName(){
    if(gSelConverter == GENEPIX){
      genePixPL.editFileName();
    } else if(gSelConverter == IMAGENE){
      imaGenePL.editFileName();
    } else if(gSelConverter == SCANARRAY){
      scanArrayPL.editFileName();
    } else if(gSelConverter == ARRAYVERSION){
      arrayVersionPL.editFileName();
    } else if(gSelConverter == ALIGENT){
      aligentPL.editFileName();
    } else if(gSelConverter == TAV){
      tavPL.editFileName();
    } else if(gSelConverter == MEV){
      mevPL.editFileName();
    } else if(gSelConverter == CUSTOMER){
      gCustomerPL.editFileName();
    }
  }

  /*****************************************************************************
   * <b>Description: </b>
   *   presnets a file chooser window for selecting files.
   * <b>Parameters: </b>
   * <p>  ext --- file name extension;
   * <br> fileType --- describe the file type;
   * <br> path --- the path the program is running or file located.
   * <p><b>Return: </b> the file name.
   ***************************************************************************/
  private File getFile(String[] ext, String fileType, String path) {
    int result, i;
    String tempName[];
    File file;
    JFileChooser fileChooser = new JFileChooser(path);
    if(ext != null){
      MadamFileFilter wanted = new MadamFileFilter(ext, fileType);
      fileChooser.setFileFilter(wanted);
    }
    fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
    fileChooser.setMultiSelectionEnabled(false);
    fileChooser.setDialogTitle(TITLE + " -- selecting files");
    result = fileChooser.showOpenDialog(this);

    if(result == JFileChooser.CANCEL_OPTION || result < 0){
      return null;
    }

    file = fileChooser.getSelectedFile();
    if(!file.isFile()){
      alertUsers("The file (" + file.getName() + ") does not exist.");
      return null;
    }
    gSysPath = file.getPath();
    return file;
  }

  /*****************************************************************************
   * <b>Description: </b>
   *   presnets a file chooser window for selecting files.
   * <b>Parameters: </b>
   * <p>  ext --- file name extension;
   * <br> fileType --- describe the file type;
   * <br> path --- the path the program is running or file located.
   * <p><b>Return: </b> the file names.
   ***************************************************************************/
  private String[] getFileName(String[] ext, String fileType, String path) {
    int result, numFile, i;
    String temp[], tempName[];
    File files[];
    JFileChooser fileChooser = new JFileChooser(path);
    if(ext != null){
      MadamFileFilter wanted = new MadamFileFilter(ext, fileType);
      fileChooser.setFileFilter(wanted);
    }
    fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
    fileChooser.setMultiSelectionEnabled(true);
    fileChooser.setDialogTitle(TITLE + " -- selecting files");
    result = fileChooser.showOpenDialog(this);

    if(result == JFileChooser.CANCEL_OPTION || result < 0){
      return null;
    }

    files = fileChooser.getSelectedFiles();
    numFile = files.length;
    temp = new String[numFile];
    tempName = new String[numFile];

    for(i=0; i<numFile; i++){
      temp[i] = new String(files[i].getPath());
      tempName[i] = new String(files[i].getName());
      if(!files[i].isFile()) {
        alertUsers("The file (" + tempName[i] + ") does not exsit.");
        return null;
      }
    }
    gSysPath = IOUtil.extractPath(temp[numFile-1]);

    if(ext != null){
      if(!isValidFileName(tempName, ext)) {
        return null;
      }
    }
    return temp;
  }

  /***************************************************************************
   * <b>Descripiton: </b>
   *    tests what OS on which this program is running
   * <p><b>Parameter: </b>
   * <br> sysOs --- a string that contains OS info.
   * <p><b>Return: </b> 1: Mac OS; otherwise, others.
   ***************************************************************************/
  private int getOperationSystem(String sysOs){
    if(sysOs.startsWith("W") || sysOs.startsWith("w")){
      return 0;
    } else {
      return 1;
    }
  }

  /*****************************************************************************
   * <b>Description: </b>
   *    create a GUI for program
   ****************************************************************************/
  public void createGUI(){
    int btnWidth = 60;
    int btnHeight = 23;

    this.setIconImage(iconPic);
    this.setTitle(title);
    this.addWindowListener(new WindowAdapter(){
      public void windowClosing(WindowEvent we){
        quit();
      }
    });
    initialMenuBar();
    initialToolBar();

    basePanel = new JPanel(new GridBagLayout());

    inputTP = new JTabbedPane();
    inputTP.setSize(gSizeX-10, (int)(gSizeY * 0.66));
    inputTP.setPreferredSize(inputTP.getSize());
    inputTP.add("  GenePix  ", genePixPL);
    inputTP.add("  ImaGene  ", imaGenePL);
    inputTP.add("  ScanArray  ", scanArrayPL);
    inputTP.add("  ArrayVision  ", arrayVersionPL);
    inputTP.add("  Agilent  ", aligentPL);
    inputTP.add("  TAV  " ,  tavPL);
    inputTP.add("  MEV  ", mevPL);
    inputTP.add("  Customized  ", gCustomerPL);

    inputTP.addChangeListener(new ChangeListener(){
      public void stateChanged(ChangeEvent ce){
        outputCB.setEnabled(true);

        if(inputTP.getSelectedComponent() == genePixPL){
          gSelConverter = GENEPIX;
          activateButton(genePixPL.isOutputReady(), genePixPL.isOutputReady());
          outputCB.setSelectedIndex(genePixPL.getOutputTypeFromFile());

        } else if(inputTP.getSelectedComponent() == imaGenePL){
          gSelConverter = IMAGENE;
          activateButton(imaGenePL.isOutputReady(), imaGenePL.isDataDirty());
          outputCB.setSelectedIndex(imaGenePL.getOutputTypeFromFile());

        } else if(inputTP.getSelectedComponent() == scanArrayPL){
          gSelConverter = SCANARRAY;
          activateButton(scanArrayPL.isOutputReady(), scanArrayPL.isOutputReady());
          outputCB.setSelectedIndex(scanArrayPL.getOutputTypeFromFile());

        } else if(inputTP.getSelectedComponent() == arrayVersionPL){
          gSelConverter = ARRAYVERSION;
          activateButton(arrayVersionPL.isOutputReady(), arrayVersionPL.isOutputReady());
          outputCB.setSelectedIndex(1);

        } else if(inputTP.getSelectedComponent() == aligentPL){
          gSelConverter = ALIGENT;
          activateButton(aligentPL.isOutputReady(), aligentPL.isOutputReady());
          outputCB.setSelectedIndex(1);

        } else if(inputTP.getSelectedComponent() == tavPL){
          gSelConverter = TAV;
          activateButton(tavPL.getOutputReady(), tavPL.getOutputReady());
          outputCB.setSelectedIndex(1);

        } else if(inputTP.getSelectedComponent() == mevPL){
          gSelConverter = MEV;
          activateButton(mevPL.getOutputReady(), mevPL.getOutputReady());
          outputCB.setSelectedIndex(0);

        } else if(inputTP.getSelectedComponent() == gCustomerPL){
          gSelConverter = CUSTOMER;
          activateButton(gCustomerPL.getOutputReady(), gCustomerPL.getOutputReady());
          outputCB.setSelectedIndex(0);
        }
        setPreferenceState();
        gDirtyData = true;
      }
    });

    progLabel = new JLabel("");
    progLabel.setPreferredSize(new Dimension(btnWidth, btnHeight));
    infoLB = new JLabel("");
    infoLB.setPreferredSize(new Dimension(btnWidth, btnHeight));
    bar = new JProgressBar();
    bar.setBorder(low);
    bar.setStringPainted(true);

    toolBarPanel = new JPanel();
    toolBarPanel.setLayout(new FlowLayout(FlowLayout.LEFT, 0, 0));
    toolBarPanel.setSize(gSizeX-10, 30);
    toolBarPanel.setPreferredSize(toolBarPanel.getSize());

    int baseHigh = gSizeY - toolBarPanel.getSize().height - 60;
    basePanel.setPreferredSize(new Dimension(gSizeX-10, baseHigh));

    toolBarPanel.add(fileToolBar);
    toolBarPanel.add(editToolBar);
    toolBarPanel.add(helpToolBar);
    toolBarPanel.add(outSelBar);

    this.getContentPane().add(toolBarPanel, BorderLayout.NORTH);
    this.getContentPane().add(basePanel, BorderLayout.CENTER);


    this.addComponentListener(new ComponentListener(){
     public void componentResized(ComponentEvent ce){
       gSizeX = getWidth();
       gSizeY = getHeight();
       if(gSizeY > scrHeight || gSizeY > 1000){
         gSizeY = scrHeight - 30;
       }
       gDirtyData = true;
     }
     public void componentMoved(ComponentEvent ce){
       gLocX = (int)getLocation().getX();
       gLocY = (int)getLocation().getY();
     }
     public void componentShown(ComponentEvent ce){}
     public void componentHidden(ComponentEvent ce){}
   });


    gba.add(basePanel, inputTP, 0, 0, 1, 1, 1, 1, GBA.B, GBA.C, 3, 5, 3, 5);
    gba.add(basePanel, infoLB, 0, 1, 1, 1, 1, 0, GBA.H, GBA.C, 8, 5, 2, 5);
    gba.add(basePanel, progLabel, 0, 2, 1, 1, 1, 0, GBA.H, GBA.C, 2, 5, 2, 5);
    gba.add(basePanel, bar, 0, 3, 1, 1, 1, 0, GBA.H, GBA.C, 1, 5, 5, 5);

     // set the interface at the center of the screen
    resize(gSizeX, gSizeY);
    if(gLocX < 0 && gLocY  < 0){
      gLocX = (scrWidth - gSizeX) >> 1;
      gLocY = (scrHeight - 25 - gSizeY) >> 1;
      if(gLocY < 0){
        gLocY = 0;
      }
    }

    setLocation(gLocX, gLocY);
    setWindowFeel(gScrFeel);
    pack();
  }

  /***************************************************************************
   * <b>Description: </b.
   *   overrides the abstract method to handle button events.
   **************************************************************************/
  public void actionPerformed (ActionEvent ae){
    adjustToolBar();
    if(ae.getSource() == stopBtn || ae.getSource() == stopMI){
      terminate();
    } else if (ae.getSource() == convertBtn || ae.getSource() == gRunMI){
      convertFiles();
    } else if (ae.getSource() == clearBtn || ae.getSource() == resetMI){
      reset();
    } else if (ae.getSource() == helpBtn || ae.getSource() == helpMI){
      showHelp();
    } else if (ae.getSource() == fileBrowserBtn || ae.getSource() == gLoadMI){
      loadInputFiles();
    } else if (ae.getSource() == deleteBtn || ae.getSource() == deleteMI){
      removeFile();
    } else if (ae.getSource() == editBtn || ae.getSource() == changeNameMI){
      editFileName();
    } else if (ae.getSource() == exitMI){
      quit();
    } else if (ae.getSource() == viewLogBtn || ae.getSource() == viewLogMI){
      showLogContent();

    } else if (ae.getSource() == gAnnBtn || ae.getSource() == gAnnOneCkbox ||
      ae.getSource() == gAnnManyCkbox){
      setAnnFileType();

    } else if (ae.getSource() == gSaveBtn || ae.getSource() == gSaveMI){
      saveCustomerHeader();

    } else if (ae.getSource() == gOpenBtn || ae.getSource() == gOpenMI){
      openCustomerHeader();

    } else if (ae.getSource() == aboutMI){
      if(!projector.isFaceOn()){
        showAbout(false);
      } else {
        projector.terminate();
        showAbout(false);
      }
    } else if(ae.getSource() == changeDirMI || ae.getSource() == changeDirBtn){
      changeDirectory();
    } else if(ae.getSource() == winViewMI){
      gScrFeel = 1;
      setWindowFeel(gScrFeel);
      adjustToolBar();
    } else if(ae.getSource() == prefMI){
      setOption();
    } else if(ae.getSource() == metalViewCkbox) {
      gScrFeel = 0;
      setWindowFeel(gScrFeel);
      adjustToolBar();
    } else if(ae.getSource() == motifViewMI){
      gScrFeel = 2;
      setWindowFeel(gScrFeel);
      adjustToolBar();
    }
  }

  /****************************************************************************
   * <b>Description: </b>
   *   activate the buttons to meet the function needs.
   ***************************************************************************/
  public void activateButton(boolean go, boolean clear){
    convertBtn.setEnabled(go);
    gRunMI.setEnabled(go);
    clearBtn.setEnabled(clear);
    resetMI.setEnabled(clear);
    changeDirBtn.setEnabled(clear);
    changeDirMI.setEnabled(clear);
    changeNameMI.setEnabled(clear);
    editBtn.setEnabled(clear);
    stopBtn.setEnabled(false);
    stopMI.setEnabled(false);

    if(gSelConverter == CUSTOMER){
      gSaveBtn.setEnabled(clear);
      gSaveMI.setEnabled(clear);
      gOpenBtn.setEnabled(gCustomerPL.getOutputReady());
      gOpenMI.setEnabled(gCustomerPL.getOutputReady());
    } else {
      gSaveBtn.setEnabled(false);
      gSaveMI.setEnabled(false);
      gOpenBtn.setEnabled(false);
      gOpenMI.setEnabled(false);
    }
  }

  /***************************************************************************
   * <b>Description: </b>
   *    creats a menu bar to control the program.
   **************************************************************************/
  private void initialMenuBar(){
    browserIcon = new ImageIcon(Toolkit.getDefaultToolkit().
      getImage(ClassLoader.getSystemResource("images/brwsdir.gif")));
    deleteIcon = new ImageIcon(Toolkit.getDefaultToolkit().
      getImage(ClassLoader.getSystemResource("images/delete.gif")));
    editIcon = new ImageIcon(Toolkit.getDefaultToolkit().
      getImage(ClassLoader.getSystemResource("images/edit.gif")));
    runIcon = new ImageIcon(Toolkit.getDefaultToolkit().
      getImage(ClassLoader.getSystemResource("images/runconvt.gif")));
    stopIcon = new ImageIcon(Toolkit.getDefaultToolkit().
      getImage(ClassLoader.getSystemResource("images/stop.gif")));
    clearIcon = new ImageIcon(Toolkit.getDefaultToolkit().
      getImage(ClassLoader.getSystemResource("images/erase.gif")));
    viewLogIcon = new ImageIcon(Toolkit.getDefaultToolkit().
      getImage(ClassLoader.getSystemResource("images/vlog.gif")));
    helpIcon = new ImageIcon(Toolkit.getDefaultToolkit().
      getImage(ClassLoader.getSystemResource("images/help.gif")));
    changeDirIcon = new ImageIcon(Toolkit.getDefaultToolkit().
      getImage(ClassLoader.getSystemResource("images/chdir.gif")));
    gAnnOneIcon = new ImageIcon(Toolkit.getDefaultToolkit().
      getImage(ClassLoader.getSystemResource("images/oneone.gif")));
    gAnnManyIcon = new ImageIcon(Toolkit.getDefaultToolkit().
      getImage(ClassLoader.getSystemResource("images/onemany.gif")));
    gOpenIcon = new ImageIcon(Toolkit.getDefaultToolkit().
      getImage(ClassLoader.getSystemResource("images/openfile.gif")));
    gSaveIcon = new ImageIcon(Toolkit.getDefaultToolkit().
      getImage(ClassLoader.getSystemResource("images/save.gif")));

    menuBar = new JMenuBar ();  // menuBar hold all menus
    setJMenuBar(menuBar);

    // begin to add menu components
    fileMenu = new JMenu ("File");   // fileMenu holds several menuItems
    fileMenu.setMnemonic ('F');
    menuBar.add(fileMenu);

    gLoadMI = new JMenuItem(" Select input files ...", browserIcon);
    gLoadMI.addActionListener(this);

    gOpenMI = new JMenuItem(" Open header file ...", gOpenIcon);
    gOpenMI.addActionListener(this);
    gOpenMI.setEnabled(false);

    gSaveMI = new JMenuItem(" Save header file ...", gSaveIcon);
    gSaveMI.addActionListener(this);
    gSaveMI.setEnabled(false);

    gRunMI = new JMenuItem(" Start converting", runIcon);
    gRunMI.setEnabled(false);
    gRunMI.addActionListener(this);

    stopMI = new JMenuItem(" Stop converting", stopIcon);
    stopMI.addActionListener(this);
    stopMI.setEnabled(false);

    prefMI = new JMenuItem("         Preference ...");
    prefMI.addActionListener(this);

    exitMI = new JMenuItem("         Exit");
    exitMI.addActionListener(this);

    fileMenu.add(gLoadMI);
    fileMenu.add(gOpenMI);
    fileMenu.add(gSaveMI);
    fileMenu.addSeparator();
    fileMenu.add(gRunMI);
    fileMenu.add(stopMI);
    fileMenu.addSeparator();
    fileMenu.add(prefMI);
    fileMenu.addSeparator();
    fileMenu.add(exitMI);

    editMenu = new JMenu("Edit");
    editMenu.setMnemonic('E');
    menuBar.add(editMenu);

    changeDirMI = new JMenuItem(" Change directory", changeDirIcon);
    changeDirMI.setEnabled(false);
    changeDirMI.addActionListener(this);

    changeNameMI = new JMenuItem(" Change file name", editIcon);
    changeNameMI.setEnabled(false);
    changeNameMI.addActionListener(this);

    deleteMI = new JMenuItem(" Delete a file", deleteIcon);
    deleteMI.addActionListener(this);

    resetMI = new JMenuItem(" Reset", clearIcon);
    resetMI.setEnabled(false);
    resetMI.addActionListener(this);

    editMenu.add(changeDirMI);
    editMenu.add(changeNameMI);
    editMenu.add(deleteMI);
    editMenu.add(resetMI);

    viewMenu = new JMenu("View");
    viewMenu.setMnemonic('V');
    menuBar.add(viewMenu);

    btnGroup = new ButtonGroup();

    viewLogMI = new JMenuItem(" Log", viewLogIcon);
    viewLogMI.addActionListener(this);

    metalViewCkbox = new JCheckBox("Metal L&F");
    metalViewCkbox.addActionListener(this);

    winViewMI = new JCheckBox("Window L&F");
    winViewMI.addActionListener(this);

    motifViewMI = new JCheckBox("Motif L&F");
    motifViewMI.addActionListener(this);

    btnGroup.add(winViewMI);
    btnGroup.add(metalViewCkbox);
    btnGroup.add(motifViewMI);

    if(gScrFeel == 0){
      metalViewCkbox.setSelected(true);
    } else if (gScrFeel == 1){
      winViewMI.setSelected(true);
    } else {
      motifViewMI.setSelected(true);
    }

    viewPanel = new JPanel(new GridBagLayout());

    gba.add(viewPanel, metalViewCkbox, 0, 0, 1, 1, 0, 0, GBA.NONE, GBA.W, 0, 4, 0, 0);
    if(gOs != MAC) {
      gba.add(viewPanel, winViewMI, 0, 1, 1, 1, 0, 0, GBA.NONE, GBA.W, 0, 4, 0, 0);
    }
    gba.add(viewPanel, motifViewMI, 0, 2, 1, 1, 0, 0, GBA.NONE, GBA.W, 0, 4, 0, 0);

    viewMenu.add(viewLogMI);
    viewMenu.addSeparator();
    viewMenu.add(viewPanel);

    annMenu = new JMenu("Ann File");
    annMenu.setMnemonic('A');
    menuBar.add(annMenu);

    gAnnGroup = new ButtonGroup();

    gAnnOneCkbox = new JCheckBox("One to One");
    gAnnOneCkbox.setToolTipText(ONE_ONE_INFO);
    gAnnOneCkbox.addActionListener(this);

    gAnnManyCkbox = new JCheckBox("Many to One");
    gAnnManyCkbox.setToolTipText(MANY_ONE_INFO);
    gAnnManyCkbox.addActionListener(this);

    gAnnGroup.add(gAnnOneCkbox);
    gAnnGroup.add(gAnnManyCkbox);

    gAnnOneCkbox.setSelected(true);

    gAnnTypePanel = new JPanel(new GridBagLayout());

    gba.add(gAnnTypePanel, gAnnOneCkbox, 0, 0, 1, 1, 0, 0, GBA.NONE, GBA.W, 0, 4, 0, 0);
    gba.add(gAnnTypePanel, gAnnManyCkbox, 0, 1, 1, 1, 0, 0, GBA.NONE, GBA.W, 0, 4, 0, 0);

    annMenu.add(gAnnTypePanel);

    helpMenu = new JMenu("Help");
    helpMenu.setMnemonic('H');
    menuBar.add(helpMenu);

    aboutMI = new JMenuItem("         about");
    aboutMI.addActionListener(this);

    helpMI = new JMenuItem(" Content and topics", helpIcon);
    helpMI.addActionListener(this);

    helpMenu.add(aboutMI);
    if(gOs != MAC){
      helpMenu.add(helpMI);
    }
  }

  /***************************************************************************
   * <b>Description: </b>
   *    creats a menu bar to control the program.
   **************************************************************************/
  private void initialToolBar(){
    Dimension iconSize = new Dimension(27, 27);

    fileToolBar = new JToolBar();  // begin to process ToolBar
    fileToolBar.setBorderPainted(false);
    fileToolBar.setName("File ...");

    fileBrowserBtn = new JButton(browserIcon);
    fileBrowserBtn.setToolTipText("Browser system to find input files.");
    fileBrowserBtn.setPreferredSize(iconSize);
    fileBrowserBtn.addActionListener(this);
    buttonFace(fileBrowserBtn);

    gOpenBtn = new JButton(gOpenIcon);
    gOpenBtn.setToolTipText("Open a header file.");
    gOpenBtn.setPreferredSize(iconSize);
    gOpenBtn.addActionListener(this);
    buttonFace(gOpenBtn);
    gOpenBtn.setEnabled(false);

    gSaveBtn = new JButton(gSaveIcon);
    gSaveBtn.setToolTipText("Save a header file.");
    gSaveBtn.setPreferredSize(iconSize);
    gSaveBtn.addActionListener(this);
    buttonFace(gSaveBtn);
    gSaveBtn.setEnabled(false);

    convertBtn = new JButton(runIcon);
    convertBtn.setToolTipText("Start converting the selected files");
    convertBtn.setPreferredSize(iconSize);
    convertBtn.addActionListener(this);
    buttonFace(convertBtn);
    convertBtn.setEnabled(false);

    stopBtn = new JButton(stopIcon);
    stopBtn.addActionListener(this);
    stopBtn.setEnabled(false);
    stopBtn.setPreferredSize(iconSize);
    buttonFace(stopBtn);

    fileToolBar.add(fileBrowserBtn);
    fileToolBar.add(gOpenBtn);
    fileToolBar.add(gSaveBtn);
    fileToolBar.add(convertBtn);
    fileToolBar.add(stopBtn);

    editToolBar = new JToolBar();  // begin to process editToolBar
    editToolBar.setBorderPainted(false);
    editToolBar.setName("Edit ...");

    changeDirBtn = new JButton(changeDirIcon);
    changeDirBtn.setToolTipText("Change output directory.");
    changeDirBtn.setPreferredSize(iconSize);
    changeDirBtn.addActionListener(this);
    changeDirBtn.setEnabled(false);
    buttonFace(changeDirBtn);

    editBtn = new JButton(editIcon);
    editBtn.setToolTipText("Modify the output file name.");
    editBtn.setPreferredSize(iconSize);
    editBtn.addActionListener(this);
    buttonFace(editBtn);

    deleteBtn = new JButton(deleteIcon);
    deleteBtn.setToolTipText("Remove the files from the selected list.");
    deleteBtn.addActionListener(this);
    deleteBtn.setPreferredSize(iconSize);
    buttonFace(deleteBtn);

    clearBtn = new JButton(clearIcon);
    clearBtn.setToolTipText("Clear interface and set Converter to its original status.");
    clearBtn.setEnabled(false);
    clearBtn.setPreferredSize(iconSize);
    clearBtn.addActionListener(this);
    buttonFace(clearBtn);

    gAnnBtn = new JButton(gAnnOneIcon);
    gAnnBtn.setToolTipText(ONE_ONE_INFO);
    gAnnBtn.setPreferredSize(iconSize);
    gAnnBtn.addActionListener(this);
    gAnnBtn.setName(ONE_ONE);
    buttonFace(gAnnBtn);

    editToolBar.add(changeDirBtn);
    editToolBar.add(editBtn);
    editToolBar.add(deleteBtn);
    editToolBar.add(clearBtn);
    editToolBar.add(gAnnBtn);

    outSelBar = new JToolBar();
    outSelBar.setBorderPainted(false);
    outSelBar.setName("Output Type");

    outputLB = new JLabel("Output: ");
    outputLB.setPreferredSize(new Dimension(45, 27));

    outputCB = new JComboBox(FILE_TYPE);
    outputCB.setBorder(low);
    outputCB.setPreferredSize(new Dimension(60, 27));
    outputCB.addItemListener(new ItemListener(){
      public void itemStateChanged(ItemEvent ie){
        if(ie.getStateChange() == ItemEvent.SELECTED){
          outputType = outputCB.getSelectedIndex();
          if(gSelConverter == GENEPIX){
            genePixPL.adjustGUI(outputType);
          } else if(gSelConverter == IMAGENE){
            imaGenePL.adjustGUI(outputType);
          } else if(gSelConverter == SCANARRAY){
            scanArrayPL.adjustGUI(outputType);
          } else if(gSelConverter == TAV){
            tavPL.adjustGUI(outputType);
          } else if(gSelConverter == MEV){
            mevPL.adjustGUI(outputType);
          }
        }
      }
    });

    outSelBar.add(outputLB);
    outSelBar.add(outputCB);

    helpToolBar = new JToolBar();  // begin to process helpToolBar
    helpToolBar.setBorderPainted(false);
    helpToolBar.setName("Help ...");

    viewLogBtn = new JButton(viewLogIcon);
    viewLogBtn.setToolTipText("View Log");
    viewLogBtn.setPreferredSize(iconSize);
    viewLogBtn.addActionListener(this);
    buttonFace(viewLogBtn);

    helpBtn = new JButton(helpIcon);
    helpBtn.setToolTipText("Open Manual.");
    helpBtn.setPreferredSize(iconSize);
    helpBtn.addActionListener(this);
    buttonFace(helpBtn);

    if(gOs != MAC){
      helpToolBar.add(helpBtn);
    }
    helpToolBar.add(viewLogBtn);
  }

  /*****************************************************************************
   * <b>Description: </b>
   *    check if user selected a file with correct file extesion
   * <p><b>Parameters: </b>
   * <br>  names --- the file names.
   * <br>  ftypes -- the extensions to be checked.
   * <p><b>Return: </b>  true if qualified; otherwise, false.
   ***************************************************************************/
  private boolean isValidFileName(String names[], String ftypes[]){
    String temp = new String("");
    String fExt;
    int num, i, j, k;
    boolean correct = true;
    boolean oneRight;

    if(names != null) {
      num = names.length;
      for(i=0; i<num; i++){
        temp = IOUtil.getFileNameExtension(names[i]);
        oneRight = false;
        for(j=0; j<ftypes.length; j++){
          if(temp.equalsIgnoreCase(ftypes[j])){
            oneRight = true;
            j = ftypes.length;
          }
        }
        if(!oneRight){
          correct = false;
          fExt = new String("");
          for(k=0; k<ftypes.length; k++){
            fExt += ftypes[k] + "/";
          }
          fExt = fExt.substring(0, fExt.length()-1);
          alertUsers("Only " + fExt + " file is acceptable for this field.");
          i = num;
        }
      }
      if(!correct){
        return correct;
      }
    } else {
      return false;
    }
    return correct;
  }

  /*****************************************************************************
   *<b>Description: </b>
   *   read and retrieve config information from .ini file for the program
   ***************************************************************************/
  private void loadConfigInfo(String fName){
    try {
      FileReading fr = new FileReading(fName);
      if(fr.done){
        initFile = fr.getFileContentInLines();
      } else {
        terminateProgram(fr.getProcessMessage());
      }
    } catch (IOException e){
      terminateProgram(e.getMessage());
    }


    gSizeX = Integer.parseInt(MyIni.getSingleValueFromIni(initFile, SCREEN_X));
    gSizeY = Integer.parseInt(MyIni.getSingleValueFromIni(initFile, SCREEN_Y));
    gScrFeel = Integer.parseInt(MyIni.getSingleValueFromIni(initFile, SCREEN_FEEL));
    gSelConverter = Integer.parseInt(MyIni.getSingleValueFromIni(initFile, SCREEN_PREF));
    gLocX = Integer.parseInt(MyIni.getSingleValueFromIni(initFile, LOC_X));
    gLocY = Integer.parseInt(MyIni.getSingleValueFromIni(initFile, LOC_Y));
    gUserTypes = MyIni.getSingleValueFromIni(initFile, CUST_FILE);
    gFileLine = Integer.parseInt(MyIni.getSingleValueFromIni(initFile, CUST_LINE));
    gVer = MyIni.getSingleValueFromIni(initFile, VERSION);

    gUserTypes = MyIni.removeEndSpace(gUserTypes);
    gCustType = setCustomizedFileType(gUserTypes);

    if(gSizeX > scrWidth){
      gSizeX = scrWidth;
    }
  }

  /****************************************************************************
   * <b>Description: </b>
   *   open a file choose window to select the input files
   **************************************************************************/
  private void loadInputFiles(){
    String fNames[] = null;

    if(gSelConverter == GENEPIX){
      fNames = getFileName(gfType, "GenePix File", gSysPath);
    } else if(gSelConverter == IMAGENE){
      fNames = getFileName(txtType, "ImaGene File", gSysPath);
    } else if(gSelConverter == SCANARRAY){
      fNames = getFileName(txtType, "ScanArray File", gSysPath);
    } else if(gSelConverter == ARRAYVERSION){
      fNames = getFileName(txtType, "ArrayVersion File", gSysPath);
    } else if(gSelConverter == ALIGENT){
      fNames = getFileName(txtType, "Agilent File", gSysPath);
    } else if(gSelConverter == TAV){
      fNames = getFileName(tavType, "TAV File", gSysPath);
    } else if(gSelConverter == MEV){
      fNames = getFileName(mevType, "MEV File", gSysPath);
    } else if(gSelConverter == CUSTOMER){
      fNames = getFileName(gCustType, "Your Input File", gSysPath);
    }

    if(fNames != null){
      if(gSelConverter == GENEPIX){
        genePixPL.setSelectedFiles(fNames);
      } else if(gSelConverter == IMAGENE){
        imaGenePL.setSelectedFiles(fNames);
      } else if(gSelConverter == SCANARRAY){
        scanArrayPL.setSelectedFiles(fNames);
      } else if(gSelConverter == ARRAYVERSION){
        arrayVersionPL.setSelectedFiles(fNames);
      } else if(gSelConverter == ALIGENT){
        aligentPL.setSelectedFiles(fNames);
      } else if(gSelConverter == TAV){
        tavPL.setSelectedFiles(fNames);
      } else if(gSelConverter == MEV){
        mevPL.setSelectedFiles(fNames);
      } else if(gSelConverter == CUSTOMER){
        gCustomerPL.setSelectedFiles(fNames);
      }
    }
  }

  /****************************************************************************
   * <b>Descripiton: </b>
   *   open the header information file to for Customize conversion.
   **************************************************************************/
  private void saveCustomerHeader(){
    gSysPath = gCustomerPL.saveHeader(gSysPath);
  }

  private void quit(){
    if(helpWinOn) {
      runner.terminate();
    }
    if(gDirtyData){
      changeInitFile();
      IOUtil.writeToFileLineByLine((JFrame)this, iniFileName, initFile);
    }
    System.exit(0);
  }

  /*****************************************************************************
   * <b>Description: </b>
   *    presents a pop-up window to inform users an error
   * <p><b>Parameter: </b>
   * <br> msg --- the message to be showed.
   ***************************************************************************/
  public void alertUsers(String msg){
    getToolkit().beep();
    JOptionPane.showMessageDialog(this, msg, "You make a mistake ... ",
      JOptionPane.ERROR_MESSAGE);
  }

  public Vector getCustomizedFileTypes() {
    Vector vec = new Vector(gCustType.length);
    for(int i=0; i<gCustType.length; i++){
      vec.add(gCustType[i]);
    }
    return vec;
  }

  public int getLocationX() { return gLocX; }
  public int getLocationY() { return gLocY; }
  public int getPreviewLine() { return  gFileLine; }
  public String getVersion() { return gVer; }

  public static void main(String arg[]){
    gSysPath = System.getProperty("user.dir")+System.getProperty("file.separator");
    iconPic = Toolkit.getDefaultToolkit().
      getImage(ClassLoader.getSystemResource("images/convticon.gif"));
    scrWidth = Toolkit.getDefaultToolkit().getScreenSize().width;
    scrHeight = Toolkit.getDefaultToolkit().getScreenSize().height;

    showAbout(true);
    projector.setTextColor(Color.green);
    projector.setInfoText("    Start runing ExpressConverter, ver.1.7 ... ");
    ExpressConverter exc = new ExpressConverter(TITLE);
    exc.show();
    projector.setInfoText("    Program loading is successful ... ");
    projector.terminate();
  }

  /*****************************************************************************
   *<b>Description: </b>
   *  presents information about ExpressConverter and lauching progress.
   *<p><b>Parameter: </b>
   *<br> load -- true if the program is lauching;
   ***************************************************************************/
  static void showAbout(boolean load) {
    Image image=Toolkit.getDefaultToolkit().
      getImage(ClassLoader.getSystemResource("images/convertface.gif"));
    proPic = new Proface(image, Proface.SHOW_INFO_BUTTON, Color.black);
    proPic.addPropertyChangeListener(new PropertyChangeListener(){
      public void propertyChange(PropertyChangeEvent pe){
        if(pe.getPropertyName().equals(Proface.CREDIT)){
          presentThanks();
        }
      }
    });
    projector = new ProfaceProjector(proPic, load);
    projector.start();

    if(!load){
      projector.setTextColor(Color.green);
      projector.setButtonTextColor(Color.green);

      projector.setButtonText(" Acknowledgments  ");
      projector.setInfoText("   Jerry Li and John Quackenbush. ");
    }
  }

  /*****************************************************************************
   *<b>Desc1ription: </b>
   *  presets credit information about ExpressConverter.
   *<p><b>Parameter: </b>
   *<br> load -- true if the program is lauching;
   ***************************************************************************/
  static void presentThanks() {
    JTextArea ta = new JTextArea();

    StringBuffer  thank = new StringBuffer(100);
    thank.append("We thank following people for their great contributions:\n\n");
    thank.append("Vasily Sharov at TIGR for his valuable comments about intensity conversion\n");
    thank.append("     algorithms.\n");
    thank.append("Dr. Joseph White at TIGR for his spot mapping algorithms.\n");
    thank.append("Dr. Wes Warren at Washington University, St. Louis, for providing information\n");
    thank.append("     about ScanArray file format.\n");
    thank.append("Dr. Dave Berger at the University of Pretoria, South Africa, for providing\n");
    thank.append("     information about ArrayVision file format.\n");
    thank.append("Vu Chu at University of Washington for his protype to convert Agilent file.\n");

    ta.setSize(proPic.getImageWidth(), proPic.getImageHeight());
    creditWin = new Proface(ta, thank.toString(), Color.black);
    creditWin.addPropertyChangeListener(new PropertyChangeListener(){
      public void propertyChange(PropertyChangeEvent pe){
        if(pe.getPropertyName().equals(Proface.CLOSE)) {
          projector.terminate();
        }
      }
    });

    projector.setFace(creditWin);

    projector.setButtonTextColor(Color.green);
    projector.setTextColor(Color.yellow);
  }

  /****************************************************************************
   * <b>Description: </b>
   *   stop the conversion by kill thread.
   ***************************************************************************/
  public void terminate(){
    if(genepixTavConvt != null){
      if(genepixTavConvt.isAlive()){
        genepixTavConvt.stop();
      }
    }
    if(genepixMevConvt != null){
      if(genepixMevConvt.isAlive()){
        genepixMevConvt.stop();
      }
    }
    if(imaGeneTavConvt != null){
      if(imaGeneTavConvt.isAlive()){
        imaGeneTavConvt.stop();
      }
    }
    if(imaGeneMevConvt != null){
      if(imaGeneMevConvt.isAlive()){
        imaGeneMevConvt.stop();
      }
    }
    if(scanArrayTavConvt != null){
      if(scanArrayTavConvt.isAlive()){
        scanArrayTavConvt.stop();
      }
    }
    if(arrayVersionMevConvt != null){
      if(arrayVersionMevConvt.isAlive()){
        arrayVersionMevConvt.stop();
      }
    }
    if(aligentMevConvt != null){
      if(aligentMevConvt.isAlive()){
        aligentMevConvt.stop();
      }
    }
    if(tavMevConvt != null){
      if(tavMevConvt.isAlive()){
        tavMevConvt.stop();
      }
    }
    if(mevTavConvt != null){
      if(mevTavConvt.isAlive()){
        mevTavConvt.stop();
      }
    }
    if(gCustMevConvt != null){
      if(gCustMevConvt.isAlive()){
        gCustMevConvt.stop();
      }
    }

    info = "";
    progCounter = progEnd;
    cvTimer.stop();
    progLabel.setText("Converting is stopped.");
    stopBtn.setEnabled(false);
    stopMI.setEnabled(false);
    clearBtn.setEnabled(true);
    resetMI.setEnabled(true);
    convertBtn.setEnabled(true);
    fileBrowserBtn.setEnabled(true);
    deleteBtn.setEnabled(true);
    changeDirBtn.setEnabled(true);
    changeDirMI.setEnabled(true);
    changeNameMI.setEnabled(true);
    editBtn.setEnabled(true);
  }

  /**************************************************************************
   * <b>Description: </b>
   *   check if an entered file is qualified for saving.
   * <p><b>Parameter: </b>
   * <br> fName -- the file name.
   * <br> needTest -- indicates if the passed file name need to be tested.
   * <p><b>Return: </b>  the test results: -1 -- quit; 0 -- no overwrite;
   *                     1 -- overwrite one file; 2 -- overwrite all files.
   **************************************************************************/
  public int validFile(String fName, boolean needTest, int btnShow){
    String name = new String(fName);
    String folder = new String("");
    int confirm = 1;
    JFrame jf = new JFrame();
    File targFile = null;

    folder = IOUtil.extractPath(name);
    folder = IOUtil.makeDir(folder);
    if(needTest){
      targFile = new File(name);

      if(targFile.exists()) {
        jf.getToolkit().beep();
        ConfirmUsers cu = new ConfirmUsers(jf, title,
          "The file \"" + name +"\" already exists, do you want to replace " +
          "the existing file?", btnShow, true);
        confirm = cu.getConfirmed();
      }
    } else {
      confirm = 2;
    }

    return confirm;
  }

  /****************************************************************************
   * <b>Description: </b>
   *   set the interface to its original status.
   **************************************************************************/
  private void reset(){
    if(gSelConverter == GENEPIX){
      genePixPL.reset();
    } else if (gSelConverter == IMAGENE){
      imaGenePL.reset();
    } else if(gSelConverter == SCANARRAY){
      scanArrayPL.reset();
    } else if(gSelConverter == ARRAYVERSION){
      arrayVersionPL.reset();
    } else if(gSelConverter == ALIGENT){
      aligentPL.reset();
    } else if(gSelConverter == TAV){
      tavPL.reset();
    } else if(gSelConverter == MEV){
      mevPL.reset();
    } else if(gSelConverter == CUSTOMER){
      gCustomerPL.reset();
    }
    progLabel.setText(info);
    infoLB.setText("");

    fileBrowserBtn.setEnabled(true);
    deleteBtn.setEnabled(true);

    bar.setValue(0);
  }

  /***************************************************************************
   * <b>Description: </b>
   *   delete a selected file from the list.
   *************************************************************************/
  private void removeFile(){
    if(gSelConverter == GENEPIX){
      genePixPL.removeFileFromList();
    } else if (gSelConverter == IMAGENE) {
      imaGenePL.removeFileFromList();
    } else if(gSelConverter == SCANARRAY){
      scanArrayPL.removeFileFromList();
    } else if(gSelConverter == ARRAYVERSION){
      arrayVersionPL.removeFileFromList();
    } else if(gSelConverter == ALIGENT){
      aligentPL.removeFileFromList();
    } else if(gSelConverter == TAV){
      tavPL.removeFileFromList();
    } else if(gSelConverter == MEV){
      mevPL.removeFileFromList();
    } else if(gSelConverter == CUSTOMER){
      gCustomerPL.removeFileFromList();
    }
  }

  /****************************************************************************
   * <b>Descripiton: </b>
   *   save the header information to a file for Customize conversion.
   **************************************************************************/
  private void openCustomerHeader(){
    File hdFile = null;
    hdFile = getFile(ECH, CUS_HEADER_FILE, gSysPath);
    if(hdFile != null){
      gCustomerPL.loadHeader(hdFile);
    }
  }

  /**************************************************************************
   * <b>Description: </b>
   *   assigns value to gAnnType and adjust GUI.
   **************************************************************************/
  private void setAnnFileType(){
    if(gAnnBtn.getName().equals(ONE_ONE)){
      gAnnType = ALL_FILES;
      gAnnBtn.setIcon(gAnnManyIcon);
      gAnnBtn.setName(MANY_ONE);
      gAnnBtn.setToolTipText(MANY_ONE_INFO);
      gAnnManyCkbox.setSelected(true);
    } else {
      gAnnType = ONE_FILE;
      gAnnBtn.setIcon(gAnnOneIcon);
      gAnnBtn.setName(ONE_ONE);
      gAnnBtn.setToolTipText(ONE_ONE_INFO);
      gAnnOneCkbox.setSelected(true);
    }
  }

  /***************************************************************************
   * <b>Description: </b>
   *    creates an array of customized file types.
   * <p><b>Parameter: </b>
   * <br> type --- a string that defines the set of type.
   * <p><b>Return: </b>  the array of types.
   *************************************************************************/
  private String[] setCustomizedFileType(String type){
    int i = 0;
    StringTokenizer token = new StringTokenizer(type, " ");
    String[] temp = new String[token.countTokens()];
    while(token.hasMoreTokens()){
      temp[i++] = token.nextToken();
    }
    return temp;
  }

  /****************************************************************************
   *<b>Description: </b>
   *   show users a pop-up window for editing parameters in the configuration
   *   file.
   ***************************************************************************/
  private void setOption(){
    String types;

    ConverterOption ctOption = new ConverterOption(this, true);
    ctOption.show();

    if(ctOption.dataEntered && ctOption.dirtyData){
      gUserTypes = ctOption.getCustomizedFileNameExtensions();
      gCustType = setCustomizedFileType(gUserTypes);
      gFileLine = ctOption.getPreviewFileSize();
      gDirtyData = true;
    }
  }

  /***************************************************************************
   * <b>Descripiton: </b>
   *    modifies the GUI based on user's preference, which is saved in .ini
   ***************************************************************************/
  private void setPreferenceState(){
    inputTP.setSelectedIndex(gSelConverter);
    outputCB.setSelectedIndex(0);
    outputCB.setSelectedIndex(1);

    if(gSelConverter == MEV){
      outputType = TAV_OUT;
      mevPL.adjustGUI(outputType);
      outputCB.setSelectedIndex(outputType);
      outputCB.setEnabled(false);

    } else if(gSelConverter == TAV || gSelConverter == ARRAYVERSION ||
              gSelConverter == ALIGENT || gSelConverter == CUSTOMER){
      outputCB.setEnabled(false);
    } else {
      outputCB.setEnabled(true);
    }

    if(gSelConverter == IMAGENE || gSelConverter == MEV || gSelConverter == ARRAYVERSION){
      gAnnBtn.setEnabled(false);
      gAnnOneCkbox.setEnabled(false);
      gAnnManyCkbox.setEnabled(false);
    } else {
      gAnnBtn.setEnabled(true);
      gAnnOneCkbox.setEnabled(true);
      gAnnManyCkbox.setEnabled(true);
    }
  }

  /****************************************************************************
   * <b>Description: </b>
   *    sets the window view feel based on the selection.
   * <p><b>Parameter: </b>
   * <br> sel  -- the selected feel.
   ***************************************************************************/
  private void setWindowFeel(int sel){
    try {
      if(sel == 1){
        UIManager.setLookAndFeel(new WindowsLookAndFeel());
      } else if (sel == 0){
        UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
      } else {
        UIManager.setLookAndFeel(new MotifLookAndFeel());
      }
      SwingUtilities.updateComponentTreeUI(this);
    } catch (Exception e) {}
  }

  /*****************************************************************************
   * <b>Description: </b>
   *   presents a help windows to show manual.
   ***************************************************************************/
  private void showHelp() {
    String helpFile = new String(MANUAL_NAME);
    String appl = new String("hh ");
     // the program that must be associated and should be under 'winnt' directory.
     // you may need to add the path to run the program

    if(!runner.isRunning()){
      helpWinOn = false;
    }

    if(!helpWinOn){
      runner = new ProgramRunner(appl, helpFile);
      runner.start();

      helpWinOn = true;
    }
  }

  /*****************************************************************************
   * <b>Description: </b>
   *    opens a window to show error message.
   ***************************************************************************/
  private void showLogContent(){
    if(!logWinOn){
      logViewWin = new ConverterLogView(this, logFileContent, title);
      logViewWin.show();
      logWinOn = true;
    } else {
      logViewWin.setState(JFrame.NORMAL);
      logViewWin.show();
    }
  }

  /****************************************************************************
   * <b>Description: </b>
   *    present correct messages based on convertsion progress.
   * <p><b>Parameters: </b>
   * <br> done -- true if the converting is done; otherwise false;
   * <br> error -- true if converting has error.
   **************************************************************************/
  private void showProgressMassege(boolean done, boolean error, boolean smMistake){
    if(done && !error && !smMistake){
      progLabel.setText("Converting is successful.");
    } else if (error){
      progLabel.setText("Converting is interrupted due to errors, which are showed in the Log Window.");
    } else if (smMistake){
      progLabel.setText("Converting is completed with some errors, which are showed in the Log Window.");
    } else {
      progLabel.setText("");
    }
  }


  /***************************************************************************
   * <b>Description: </b>
   *   teminate the converting process by the timer.
   ***************************************************************************/
  private void stopConverting(){
    progLabel.setText(info);
    bar.setValue(progCounter);
    progCounter = 0;
    progEnd = 1000;
    Toolkit.getDefaultToolkit().beep();
    bar.setMaximum(progEnd);
    bar.setValue(progCounter);
    cvTimer.stop();
    info = "";
    infoLB.setText(info);

    if(outputType == TAV_OUT && gSelConverter == GENEPIX){
      showProgressMassege(genepixTavConvt.ready, genepixTavConvt.fetalError,
        genepixTavConvt.minorError);
    } else if(outputType == MEV_OUT && gSelConverter == GENEPIX){
      showProgressMassege(genepixMevConvt.ready, genepixMevConvt.fetalError,
        genepixMevConvt.minorError);
    } else if (outputType == TAV_OUT && gSelConverter == IMAGENE){
      showProgressMassege(imaGeneTavConvt.ready, imaGeneTavConvt.fetalError,
        imaGeneTavConvt.minorError);
    } else if (outputType == MEV_OUT && gSelConverter == IMAGENE){
      showProgressMassege(imaGeneMevConvt.ready, imaGeneMevConvt.fetalError,
        imaGeneMevConvt.minorError);
    } else if(outputType == TAV_OUT && gSelConverter == SCANARRAY){
      showProgressMassege(scanArrayTavConvt.ready, scanArrayTavConvt.fetalError,
        scanArrayTavConvt.minorError);
    } else if(outputType == MEV_OUT && gSelConverter == SCANARRAY){
      showProgressMassege(scanArrayMevConvt.ready, scanArrayMevConvt.fetalError,
        scanArrayMevConvt.minorError);
    } else if(outputType == MEV_OUT && gSelConverter == TAV){
      showProgressMassege(tavMevConvt.ready, tavMevConvt.fetalError,
        tavMevConvt.minorError);
    } else if(outputType == TAV_OUT && gSelConverter == MEV){
      showProgressMassege(mevTavConvt.ready, mevTavConvt.fetalError,
        mevTavConvt.minorError);
    } else if(outputType == MEV_OUT && gSelConverter == ARRAYVERSION){
      showProgressMassege(arrayVersionMevConvt.ready, arrayVersionMevConvt.fetalError,
        arrayVersionMevConvt.minorError);
    } else if(outputType == MEV_OUT && gSelConverter == ALIGENT){
      showProgressMassege(aligentMevConvt.ready, aligentMevConvt.fetalError,
        aligentMevConvt.minorError);
    } else if(outputType == MEV_OUT && gSelConverter == CUSTOMER){
      showProgressMassege(gCustMevConvt.ready, gCustMevConvt.fetalError,
        gCustMevConvt.minorError);
    }
    activateButton(true, true);
  }

  /**************************************************************************
   * <b>Description: </b>
   *   terminates the program.
   *************************************************************************/
  private void terminateProgram(String msg){
    JFrame frame = new JFrame();
    frame.getToolkit().beep();
    JOptionPane.showMessageDialog(null, msg, "Error in ... ", JOptionPane.ERROR_MESSAGE);
    System.exit(1);
  }

  /*****************************************************************************
   * INNERCLASS:   ConverterListener
   * DESCRIPTION:  peridically checks progress of the converting.
   ***************************************************************************/
  class ConvertListener implements ActionListener {
    Converter convt;
    public ConvertListener(Converter c){
      convt = c;
    }

    public void actionPerformed(ActionEvent evt) {
      if(convt.fetalError){
        logFileContent.add(convt.getErrorMsg());
        stopConverting();
        return;
      }
      curTime = System.currentTimeMillis ();
      progEnd = convt.getTaskEnd();
      bar.setMaximum(convt.getTaskEnd());
      progCounter = convt.getCurrent();
      if(progCounter == 0){
        progLabel.setText("Wait, preparing for converting ...   " + "  Elapsed time: "
                          + MyTimer.changeToStandardTime((curTime - startTime)/1000));
        return;
      }
      infoLB.setText("Converting " + convt.getFileName() + " ...");
      info = "completed " + (progCounter>>1) + " out of " + (progEnd>>1) + " spots "
        + "for " + selectedChAFiles.size() + " files.   Elapsed time: "
        + MyTimer.changeToStandardTime((curTime - startTime)/1000);
      if(progCounter < progEnd) {
        progLabel.setText(info);
        bar.setValue(progCounter);
      } else if(progEnd != 0){
        logFileContent.add(convt.getErrorMsg());
        stopConverting();
        return;
      }
    }
  }
}