package us.daveread.utility.formatcheck.gui;

 import javax.swing.JFrame;

 import java.awt.HeadlessException;

 import java.awt.*;

 import java.awt.event.*;

 import javax.swing.*;

 import javax.swing.border.*;

 import java.util.*;

 import java.io.*;

 import java.text.DecimalFormat;

 import java.text.NumberFormat;

 import us.daveread.utility.formatcheck.ConstantsInterface;

 import us.daveread.utility.formatcheck.images.ImageUtility;

 import us.daveread.utility.formatcheck.print.Print;

 import us.daveread.utility.formatcheck.format.*;

 import us.daveread.utility.formatcheck.util.Configuration;

 import us.daveread.utility.sixsigma.SigmaCalculator;

 import us.daveread.utility.sixsigma.gui.SigmaCalculatorDialog;

 import org.apache.log4j.Logger;

 import org.apache.log4j.PropertyConfigurator;

 /**

  * <p>Title: FormatCheckFrame

  * <p>Description: GUI for user interaction with the FormatCheck utility

  * <p>Copyright: Copyright (c) 2005

  * <p>This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation; either version 2 of the License, or

  * (at your option) any later version.

  * <p>This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  * <p>You should have received a copy of the GNU General Public License

  * along with this program; if not, write to the Free Software

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  * </p>

  *

  * @author David Read

  * @version $Id: FormatCheckFrame.java,v 1.3 2006/06/14 23:34:01 daveread Exp $

  */

 public class FormatCheckFrame extends JFrame implements ActionListener,

         WindowListener, Runnable {

     /** Logger configuration file name */

     private final static String FILENAME_LOGGER = "FormatCheck.Logger";

     /** File name of application's icon file - must be in the

      *  us.daveread.utility.formatcheck.images package

      */

     public final static String ICON = "FormatCheckIcon.gif";

     /** The directory, relative to the application execution directory,

      *  containing the XML files woith the format definitions.

      */

     public final static String FORMAT_DIR = "Formats";

     /** The set of known format types, loaded form the format type XML files */

     private Map formatTypes;

     /** Collection of record numbers with errors reported on latest run */

     private java.util.List lastErrorRecords;

     /** The combobox allowing the user to choose a format to apply */

     private JComboBox formatTypeChoice;

     /** The label to display the chosen input file name */

     private JLabel fileNameChoice;

     /** The button used to open the File-Open dialog, to choose an input file */

     private JButton fileNameFileDialogButton;

     /** The button used to run the validation against the chosen input file */

     private JButton runButton;

     /** Display area for all validation messages */

     private JTextArea resultsDisplay;

     /** Display area for brief status messages */

     private JLabel statusDisplay;

     /** The file chosen for validation */

     private File fileChosen;

     /** Menu item to save results to a file */

     private JMenuItem menuFileSave;

     /** Menu item to print results */

     private JMenuItem menuFilePrint;

     /** Menu item to print parsed records */

     private JMenuItem menuFilePrintRecords;

     /** Menu item to print parsed records that had errors */

     private JMenuItem menuFilePrintErrorRecords;

     /** Menu item to exit program */

     private JMenuItem menuFileExit;

     /** Menu item to copy selected results to clipboard */

     private JMenuItem menuEditCopy;

     /** Menu item to select all results */

     private JMenuItem menuEditSelectAll;

     /** Menu item to open the sigma calculator */

     private JMenuItem menuToolsSigmaCalculator;

     /** Menu item to refresh XML format definitions */

     private JMenuItem menuToolsReloadFormats;

     /** Menu item to display the application "About" box */

     private JMenuItem menuHelpAbout;

     /** Logger */

     private static final Logger logger = Logger.getLogger(FormatCheckFrame.class);

     /**

      * Creates and shows the GUI

      *

      * @throws HeadlessException If there is no graphical device present

      */

     public FormatCheckFrame() throws HeadlessException {

         setupLogger();

         addWindowListener(this);

         setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);

         setTitle("FormatCheck");

         try {

             this.setIconImage(new ImageIcon(ImageUtility.getImageAsByteArray(

                     ICON)).getImage());

         } catch (Exception excAny) {

             logger.error("Failed to set icon", excAny);

         }

         setup();

         center(this, null);

         setVisible(true);

     }

     /**

      * Main GUI setup.  Loads the format types and creates the GUI widgets.

      */

     private void setup() {

         setupGUI();

         setupFormatTypes();

         setControls();

     }

     /**

      * Configure the logger

      */

     private void setupLogger() {

         PropertyConfigurator.configure(Configuration.instance().getFile(

                 FILENAME_LOGGER).getAbsolutePath());

         if (logger.isDebugEnabled()) {

             Properties props = System.getProperties();

             Set keys = props.keySet();

             Iterator keyItr = keys.iterator();

             while (keyItr.hasNext()) {

                 String key = (String) keyItr.next();

                 logger.debug("Prop: [" + key + "]=[" + System.getProperty(key) +

                              "]");

             }

         }

     }

     /**

      * Creates, populates and arranges the GUI widgets.

      */

     private void setupGUI() {

         JPanel mainPanel;

         JPanel tempPanel;

         JPanel innerPanel;

         setupMenu();

         getContentPane().setLayout(new BorderLayout());

         mainPanel = new JPanel();

         mainPanel.setLayout(new BorderLayout());

         // Upper area - controls

         tempPanel = new JPanel();

         tempPanel.setLayout(new GridLayout(0, 1));

         // Format Type Selection

         formatTypeChoice = new JComboBox();

         innerPanel = new JPanel();

         innerPanel.setLayout(new FlowLayout(FlowLayout.LEFT));

         innerPanel.add(formatTypeChoice);

         formatTypeChoice.addActionListener(this);

         tempPanel.add(innerPanel);

         // Input File Selection

         innerPanel = new JPanel();

         innerPanel.setLayout(new FlowLayout(FlowLayout.LEFT));

         innerPanel.add(fileNameFileDialogButton = new JButton("Choose File..."));

         fileNameFileDialogButton.setMnemonic('C');

         fileNameFileDialogButton.addActionListener(this);

         innerPanel.add(fileNameChoice = new JLabel());

         tempPanel.add(innerPanel);

         // Run button

         innerPanel = new JPanel();

         innerPanel.setLayout(new FlowLayout(FlowLayout.LEFT));

         innerPanel.add(runButton = new JButton("Verify File"));

         runButton.setMnemonic('V');

         runButton.addActionListener(this);

         tempPanel.add(innerPanel);

         tempPanel.setBorder(BorderFactory.createBevelBorder(BevelBorder.RAISED));

         // Add controls to top of panel

         mainPanel.add(tempPanel, BorderLayout.NORTH);

         // Add message area to center of panel

         mainPanel.add(new JScrollPane(resultsDisplay = new JTextArea(20, 50)),

                 BorderLayout.CENTER);

         resultsDisplay.setEditable(false);

         // Add status display to bottom of panel

         tempPanel = new JPanel();

         tempPanel.setLayout(new FlowLayout(FlowLayout.LEFT, 0, 0));

         tempPanel.setBorder(BorderFactory.createBevelBorder(BevelBorder.LOWERED));

         tempPanel.add(statusDisplay = new JLabel());

         statusDisplay.setFont(new Font(statusDisplay.getFont().getName(),

                                        statusDisplay.getFont().getStyle(), 9));

         mainPanel.add(tempPanel, BorderLayout.SOUTH);

         // Add all controls (entire panel) to center of window

         getContentPane().add(mainPanel, BorderLayout.CENTER);

         pack();

     }

     /**

      * Populate the combobox with the known format types

      */

     private void populateFormatTypes() {

         java.util.List lFormatTypes;

         Iterator lFormatType;

         formatTypeChoice.removeAllItems();

         lFormatTypes = new ArrayList();

         lFormatType = formatTypes.values().iterator();

         while (lFormatType.hasNext()) {

             lFormatTypes.add(lFormatType.next());

         }

         Collections.sort(lFormatTypes);

         // Place the "Choose One... selection at the top of the list

         lFormatTypes.add(0, new FormatType("Choose a Format Type...", "N/A"));

         lFormatType = lFormatTypes.iterator();

         while (lFormatType.hasNext()) {

             formatTypeChoice.addItem(lFormatType.next());

         }

     }

     /**

      * Creates the application's menu

      */

     private void setupMenu() {

         JMenuBar menuBar;

         JMenu menu;

         menuBar = new JMenuBar();

         setJMenuBar(menuBar);

         // File Menu

         menu = new JMenu("File");

         menu.setMnemonic(KeyEvent.VK_F);

         menu.getAccessibleContext().setAccessibleDescription(

                 "Menu items related to report file access");

         menuBar.add(menu);

         // File | Save

         menuFileSave = new JMenuItem("Save Results");

         menuFileSave.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S,

                 ActionEvent.CTRL_MASK));

         menuFileSave.setMnemonic(KeyEvent.VK_S);

         menuFileSave.getAccessibleContext().setAccessibleDescription(

                 "Save results to a file");

         menuFileSave.addActionListener(this);

         menu.add(menuFileSave);

         menu.addSeparator();

         // File | Print

         menuFilePrint = new JMenuItem("Print Results");

         menuFilePrint.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_P,

                 ActionEvent.CTRL_MASK));

         menuFilePrint.setMnemonic(KeyEvent.VK_P);

         menuFilePrint.getAccessibleContext().setAccessibleDescription(

                 "Print results to a printer");

         menuFilePrint.addActionListener(this);

         menu.add(menuFilePrint);

         menu.addSeparator();

         // File | Print Parsed Records

         menuFilePrintRecords = new JMenuItem("Print Records");

         menuFilePrintRecords.setMnemonic(KeyEvent.VK_R);

         menuFilePrintRecords.getAccessibleContext().setAccessibleDescription(

                 "Print records based on user-supplied record numbers");

         menuFilePrintRecords.addActionListener(this);

         menu.add(menuFilePrintRecords);

         // File | Print Error Records

         menuFilePrintErrorRecords = new JMenuItem("Print Records with Errors");

         menuFilePrintErrorRecords.setMnemonic(KeyEvent.VK_E);

         menuFilePrintErrorRecords.getAccessibleContext().

                 setAccessibleDescription(

                         "Print parsed records that had errors to a printer");

         menuFilePrintErrorRecords.addActionListener(this);

         menu.add(menuFilePrintErrorRecords);

         menu.addSeparator();

         // File | Exit

         menuFileExit = new JMenuItem("Exit");

         menuFileExit.setMnemonic(KeyEvent.VK_X);

         menuFileExit.getAccessibleContext().setAccessibleDescription(

                 "Close the FormatCheck application");

         menuFileExit.addActionListener(this);

         menu.add(menuFileExit);

         // Edit Menu

         menu = new JMenu("Edit");

         menu.setMnemonic(KeyEvent.VK_E);

         menu.getAccessibleContext().setAccessibleDescription(

                 "REsults access menu items");

         menuBar.add(menu);

         // Edit | Copy

         menuEditCopy = new JMenuItem("Copy");

         menuEditCopy.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C,

                 ActionEvent.CTRL_MASK));

         menuEditCopy.setMnemonic(KeyEvent.VK_C);

         menuEditCopy.getAccessibleContext().setAccessibleDescription(

                 "Copy the selected results");

         menuEditCopy.addActionListener(this);

         menu.add(menuEditCopy);

         menu.addSeparator();

         // Edit | Select All

         menuEditSelectAll = new JMenuItem("Select All");

         menuEditSelectAll.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_A,

                 ActionEvent.CTRL_MASK));

         menuEditSelectAll.setMnemonic(KeyEvent.VK_A);

         menuEditSelectAll.getAccessibleContext().setAccessibleDescription(

                 "Copy the selected results");

         menuEditSelectAll.addActionListener(this);

         menu.add(menuEditSelectAll);

         // Tools Menu

         menu = new JMenu("Tools");

         menu.setMnemonic(KeyEvent.VK_T);

         menu.getAccessibleContext().setAccessibleDescription(

                 "Utility menu items");

         menuBar.add(menu);

         // Tools | Sigma Calculator

         menuToolsSigmaCalculator = new JMenuItem("Sigma Calculator");

         menuToolsSigmaCalculator.setMnemonic(KeyEvent.VK_C);

         menuToolsSigmaCalculator.getAccessibleContext().

                 setAccessibleDescription(

                         "Basic Sigma Calculator");

         menuToolsSigmaCalculator.addActionListener(this);

         menu.add(menuToolsSigmaCalculator);

         menu.addSeparator();

         // Tools | Reload Definitions

         menuToolsReloadFormats = new JMenuItem("Reload Definitions");

         menuToolsReloadFormats.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.

                 VK_R,

                 ActionEvent.ALT_MASK));

         menuToolsReloadFormats.setMnemonic(KeyEvent.VK_R);

         menuToolsReloadFormats.getAccessibleContext().setAccessibleDescription(

                 "Reload the format definitions");

         menuToolsReloadFormats.addActionListener(this);

         menu.add(menuToolsReloadFormats);

         // Help Menu

         menu = new JMenu("Help");

         menu.setMnemonic(KeyEvent.VK_H);

         menu.getAccessibleContext().setAccessibleDescription(

                 "Usage and support information");

         menuBar.add(menu);

         // Help | About

         menuHelpAbout = new JMenuItem("About");

         menuHelpAbout.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_A,

                 ActionEvent.ALT_MASK));

         menuHelpAbout.setMnemonic(KeyEvent.VK_A);

         menuHelpAbout.getAccessibleContext().setAccessibleDescription(

                 "Application information");

         menuHelpAbout.addActionListener(this);

         menu.add(menuHelpAbout);

     }

     /**

      * Enables and disables widgets based on state of data.

      */

     private void setControls() {

         fileNameFileDialogButton.setEnabled(formatTypeChoice.getSelectedIndex() !=

                                             0);

         runButton.setEnabled(formatTypeChoice.getSelectedIndex() != 0 &&

                              fileChosen != null);

         if (fileChosen == null) {

             fileNameChoice.setText(fileNameFileDialogButton.isEnabled() ?

                                    "Please Select A File For Processing" : "");

         } else {

             fileNameChoice.setText(fileChosen.getName());

         }

         menuFileSave.setEnabled(resultsDisplay.getText().length() > 0);

         menuFilePrintRecords.setEnabled(runButton.isEnabled());

         menuFilePrintErrorRecords.setEnabled(runButton.isEnabled() &&

                                              lastErrorRecords.size() > 0);

         menuFilePrint.setEnabled(menuFileSave.isEnabled());

         menuEditCopy.setEnabled(menuFileSave.isEnabled());

         menuEditSelectAll.setEnabled(menuFileSave.isEnabled());

         clearStatusMessage();

     }

     /**

      * Loads the format types from the XML format definition files.

      */

     private void setupFormatTypes() {

         FormatType oneType;

         String errors;

         formatTypes = new HashMap();

         File files[] = new File(FORMAT_DIR).listFiles();

         for (int fileNum = 0; fileNum < files.length; ++fileNum) {

             if (files[fileNum].getName().toLowerCase().endsWith(".xml")) {

                 oneType = new FormatTypeParser(files[fileNum]);

                 // Error handling

                 errors = ((FormatTypeParser) oneType).getErrorMessages();

                 if (errors.length() == 0) {

                     formatTypes.put(oneType.getName(), oneType);

                     logger.debug("Added format type[" + oneType.getName() + "]");

                     logger.debug("First Record Type[" +

                                  oneType.getRecordType(0).getDescription() +

                                  "]");

                     logger.debug("First Field Name[" +

                                  oneType.getRecordType(0).getFieldType(0).

                                  getName() + "]");

                     logger.debug("First Field DataType Description[" +

                                  oneType.getRecordType(0).getFieldType(0).

                                  getDataType().getDescription() + "]");

                 } else {

                     // Errors to report

                     // Add XML file name to beginning of set of errors

                     //errors = Utils.characterInsert(errors, "\n", 60, 90, " ,:;");

                     // Only keep the first five errors, otherwise the dialog box gets

                     // too tall and the user cannot see the OK button;

                     //String errorsParsed[] = errors.split("\n");

                     //if (errorsParsed.length > 5) {

                     //  errors = "";

                     //  for (int line = 0;line < 5;++line) {

                     //    errors += errorsParsed[line] + "\n";

                     //  }

                     //}

                     //errors = Utils.characterInsert(errors, "\n", 60, 90, " ,:;");

                     errors =

                             "Errors Occured During Setup\n\nFormat File Name: " +

                             files[fileNum].getName() + "\n\n" + errors;

                     JTextArea message = new JTextArea(errors, 20, 60);

                     message.setLineWrap(true);

                     message.setWrapStyleWord(true);

                     JOptionPane.showMessageDialog(this,

                                                   new JScrollPane(message),

                                                   "XML Format File Errors",

                                                   JOptionPane.ERROR_MESSAGE);

                 }

             }

         }

         populateFormatTypes();

         clearErrorRecords();

         setControls();

     }

     /**

      * Adds a message to the results display, moving the cursor to the new

      * end position (causing the new message to scroll onto the visible area

      * if it was off the bottom).

      *

      * @param message String The message being appended into the message area

      */

     private void appendResult(String message) {

         resultsDisplay.append(message);

         resultsDisplay.setCaretPosition(resultsDisplay.getText().length());

     }

     /**

      * Clears the results display.

      */

     private void clearResult() {

         resultsDisplay.setText("");

     }

     /**

      * Sets the message in the status message widget.

      *

      * @param aMessage String The status message

      */

     private void setStatusMessage(String aMessage) {

         statusDisplay.setText(aMessage);

     }

     /**

      * Clears the status message widget.

      */

     private void clearStatusMessage() {

         statusDisplay.setText(" ");

     }

     /**

      * Centers a window on the parent window or the screen.  If the parent

      * is null, or smaller than the child, the child is centered on the

      * screen.

      *

      * @param winaChild The window being centered.

      * @param winaParent The parent window, or null if no parent frame exists.

      */

     public static void center(Window winaChild, Window winaParent) {

         Dimension dimlParentSize, dimlMySize;

         Point ptlUpperLeft;

         int ilX, ilY;

         dimlMySize = winaChild.getSize();

         if (winaParent == null) {

             dimlParentSize = Toolkit.getDefaultToolkit().getScreenSize();

             ptlUpperLeft = new Point(0, 0);

         } else {

             dimlParentSize = winaParent.getSize();

             ptlUpperLeft = winaParent.getLocation();

             if (dimlMySize.width >= dimlParentSize.width ||

                 dimlMySize.height >= dimlParentSize.height) {

                 dimlParentSize = Toolkit.getDefaultToolkit().getScreenSize();

                 ptlUpperLeft = new Point(0, 0);

             }

         }

         if (dimlParentSize.width >= dimlMySize.width) {

             ilX = (dimlParentSize.width - dimlMySize.width) / 2;

         } else {

             ilX = 0;

         }

         if (dimlParentSize.height >= dimlMySize.height) {

             ilY = (dimlParentSize.height - dimlMySize.height) / 2;

         } else {

             ilY = 0;

         }

         ilX += ptlUpperLeft.x;

         ilY += ptlUpperLeft.y;

         winaChild.setLocation(ilX, ilY);

     }

     /**

      * Allows the user to choose a file to be validated.

      */

     private void chooseFile() {

         JFileChooser fileChooser;

         int returnValue;

         if (fileChosen != null) {

             fileChooser = new JFileChooser(fileChosen.getParentFile());

             fileChooser.setSelectedFile(fileChosen);

         } else {

             fileChooser = new JFileChooser();

         }

         fileChooser.setDialogTitle("Choose a File to Validate as " +

                                    formatTypeChoice.getSelectedItem());

         returnValue = fileChooser.showOpenDialog(this);

         if (returnValue == JFileChooser.APPROVE_OPTION) {

             fileChosen = fileChooser.getSelectedFile();

         } else {

             fileChosen = null;

         }

         clearErrorRecords();

         setControls();

     }

     /**

      * Verify the chosen input file using the chosen format.  The actual

      * execution is carried out on a separate thread.

      */

     private synchronized void runVerify() {

         runButton.setEnabled(false);

         try {

             new Thread(this).start();

         } catch (Throwable any) {

             appendResult("\nError during processing\nError Type: " +

                          any.getClass().getName() + "\nError Message: " +

                          any.getMessage());

             setCursor(new Cursor(Cursor.DEFAULT_CURSOR));

         }

     }

     /**

      * Print a user-entered set of records from the input file.

      */

     private void filePrintRecords() {

         String userEnteredRecords;

         String[] parsedInput, parsedEntry;

         java.util.List recordNumbers;

         int whichInput;

         int low, high;

         recordNumbers = new ArrayList();

         userEnteredRecords = JOptionPane.showInputDialog(this, "Enter a list of record numbers separated by commas\nor a range of record numbers separated by a hyphen.",

                 "Enter Record Numbers", JOptionPane.QUESTION_MESSAGE);

         if (userEnteredRecords != null &&

             userEnteredRecords.trim().length() > 0) {

             parsedInput = userEnteredRecords.split(",");

             for (whichInput = 0; whichInput < parsedInput.length; ++whichInput) {

                 parsedEntry = parsedInput[whichInput].split("-");

                 if (parsedEntry.length == 2) {

                     try {

                         low = Integer.parseInt(parsedEntry[0]);

                         high = Integer.parseInt(parsedEntry[1]);

                         if (low > high) {

                             JOptionPane.showMessageDialog(this,

                                     "The range, " +

                                     parsedInput[whichInput] +

                                     ", starts after it ends",

                                     "Error In Input Range",

                                     JOptionPane.ERROR_MESSAGE);

                         } else if (low < 1) {

                             JOptionPane.showMessageDialog(this,

                                     "The range, " +

                                     parsedInput[whichInput] +

                                     ", starts before record 1",

                                     "Error In Input Range",

                                     JOptionPane.ERROR_MESSAGE);

                         } else {

                             for (int range = low; range <= high; ++range) {

                                 recordNumbers.add(new Integer(range));

                             }

                         }

                     } catch (Throwable any) {

                         JOptionPane.showMessageDialog(this,

                                 "The range, " +

                                 parsedInput[whichInput] +

                                 ", has non-numeric values",

                                 "Error In Input Range",

                                 JOptionPane.ERROR_MESSAGE);

                     }

                 } else {

                     try {

                         low = Integer.parseInt(parsedInput[whichInput]);

                         if (low < 1) {

                             JOptionPane.showMessageDialog(this,

                                     "The record number, " +

                                     parsedInput[whichInput] +

                                     ", starts before record 1",

                                     "Error In Input Record",

                                     JOptionPane.ERROR_MESSAGE);

                         } else {

                             recordNumbers.add(new Integer(low));

                         }

                     } catch (Throwable any) {

                         JOptionPane.showMessageDialog(this,

                                 "The record number, " +

                                 parsedInput[whichInput] +

                                 ", has non-numeric values",

                                 "Error In Input Record",

                                 JOptionPane.ERROR_MESSAGE);

                     }

                 }

             }

             if (recordNumbers.size() > 0) {

                 printRecords(recordNumbers, "Records: " + userEnteredRecords);

             }

         }

     }

     /**

      * Print the records that were flagged with errors when verified

      */

     private void filePrintErrorRecords() {

         printRecords(lastErrorRecords, "Records With Reported Errors");

     }

     /**

      * Print the records from the current file, using the List of

      * Integer objects to obtain the record numbers to be printed.

      *

      * @param recordNumbers List The list of record numbers to be printed

      */

     private void printRecords(java.util.List recordNumbers, String title) {

         int[] records;

         records = new int[recordNumbers.size()];

         for (int rec = 0; rec < recordNumbers.size(); ++rec) {

             records[rec] = ((Integer) recordNumbers.get(rec)).intValue();

         }

         printParsedRecords(records, title);

     }

     /**

      * Print the records from the current file, using the integer array

      * to obtain the record numbers to be printed.

      *

      * @param recordNumbers int[] The record numbers to be printed

      */

     private void printParsedRecords(int[] recordNumbers, String title) {

         BufferedReader in;

         ProgressMonitorInputStream inProgress;

         ProgressMonitor progress;

         String oneReport;

         String data;

         StringBuffer fullReport;

         int recIndex, record;

         FormatType chosenFormatType;

         Arrays.sort(recordNumbers);

         fullReport = new StringBuffer();

         chosenFormatType = (FormatType) formatTypeChoice.getSelectedItem();

         record = 0;

         recIndex = 0;

         try {

             // Open file

             inProgress = new

                          ProgressMonitorInputStream(this,

                     "Printing Records from " +

                     fileNameChoice.getText() +

                     " as " + chosenFormatType.getName(),

                     new FileInputStream(fileChosen));

             in = new BufferedReader(new InputStreamReader(new

                     BufferedInputStream(

                             inProgress)));

             progress = inProgress.getProgressMonitor();

             // Reset validation state of format object

             chosenFormatType.newValidation();

             // Validate each record

             while (recIndex < recordNumbers.length && (data = in.readLine()) != null &&

                     !progress.isCanceled()) {

                 ++record;

                 logger.debug("record[" + record + "]");

                 if (record == recordNumbers[recIndex]) {

                     if (fullReport.length() == 0) {

                         fullReport.append("File: " + fileChosen.getAbsolutePath() +

                                           "\n");

                         fullReport.append("Format: " + chosenFormatType.getName() +

                                           "\n");

                     }

                     fullReport.append("\nLine: " + record +

                                       "\n------------------------------------------------------\n");

                     oneReport = chosenFormatType.getReportableParsedRecord(data);

                     fullReport.append(oneReport);

                     fullReport.append(

                             "------------------------------------------------------\n");

                     ++recIndex;

                 }

             }

             if (fullReport.length() > 0) {

                 Print print = new Print(title);

                 print.print(fullReport.toString(), false);

             }

         } catch (Throwable any) {

             JOptionPane.showMessageDialog(this,

                                           "Error during error record printing\nError Type: " +

                                           any.getClass().getName() +

                                           "\nError Message: " +

                                           any.getMessage(),

                                           "Error During Record Printing",

                                           JOptionPane.ERROR_MESSAGE);

             logger.error("Error printing record", any);

         }

     }

     /**

      * Clear the historical list of record numbers reported with errors

      */

     private void clearErrorRecords() {

         lastErrorRecords = new ArrayList();

     }

     /**

      * Add a record number to the historical list of record numbers reported with

      * errors.

      *

      * @param aRecordNum int The record number to add to the list

      */

     private void addErrorRecord(int aRecordNum) {

         lastErrorRecords.add(new Integer(aRecordNum));

     }

     /**

      * Reads the input file and sends each record to the chosen format

      * to be validated.  Writes the resulting messages to the message

      * area and calculates the resulting sigma.

      */

     private void verifyContent() {

         BufferedReader in;

         ProgressMonitorInputStream inProgress;

         ProgressMonitor progress;

         String data;

         FormatType chosenFormatType;

         ValidationResult oneResult;

         SigmaCalculator calc;

         int record;

         int totalOpportunities, totalDefects;

         StringBuffer results;

         Date start, setStart, setStop, remainingTime;

         long positStart, positStop;

         setCursor(new Cursor(Cursor.WAIT_CURSOR));

         results = new StringBuffer();

         clearResult();

         clearStatusMessage();

         totalOpportunities = totalDefects = 0;

         chosenFormatType = (FormatType) formatTypeChoice.getSelectedItem();

         record = 0;

         in = null;

         inProgress = null;

         progress = null;

         oneResult = null;

         clearErrorRecords();

         start = new Date();

         setStart = new Date();

         positStart = 0;

         positStop = 0;

         try {

             // Open file

             inProgress = new

                          ProgressMonitorInputStream(this,

                     "Verifying " + fileNameChoice.getText() +

                     " as " + chosenFormatType.getName(),

                     new FileInputStream(fileChosen));

             in = new BufferedReader(new InputStreamReader(new

                     BufferedInputStream(

                             inProgress)));

             progress = inProgress.getProgressMonitor();

             // Reset validation state of format object

             chosenFormatType.newValidation();

             // Validate each record

             while ((data = in.readLine()) != null && !progress.isCanceled()) {

                 ++record;

                 positStop += data.length();

                 logger.debug("record[" + record + "] length[" + data.length() +

                              "]");

                 if (data.length() == 1) {

                     logger.debug("char code[" + (int) data.charAt(0) + "]");

                 }

                 // Mainframe exports have EOF-type character at last line

                 // Ignore line in this case

                 if (data.length() == 1 && data.charAt(0) < 32) {

                     logger.debug("record[" + record +

                                  "] ignored (EOF character)");

                     continue;

                 }

                 if (record % 1000 == 0) {

                     setStop = new Date();

                     remainingTime = new Date(setStop.getTime() +

                                              (long)

                                              (((double) (setStop.getTime() -

                             setStart.getTime())) /

                                               (positStop - positStart) *

                                               (fileChosen.length() - positStop)));

                     setStatusMessage("Record: " +

                                      record +

                                      "  Elapsed: " +

                                      Utils.timeElapsedFormat(start, setStop) +

                                      "  Remaining: " +

                                      Utils.timeElapsedFormat(setStop,

                             remainingTime));

                     setStart = setStop;

                     positStart = positStop;

                 }

                 oneResult = chosenFormatType.validate(data, record);

                 totalOpportunities += oneResult.getNumOpportunities();

                 totalDefects += oneResult.getNumDefects();

                 for (int defect = 0; defect < oneResult.getNumDefects();

                                   ++defect) {

                     results.append("Line " + record + ":" +

                                    oneResult.getDefectMessage(defect) + "\n");

                 }

                 if (oneResult.getNumDefects() > 0) {

                     addErrorRecord(record);

                 }

             }

             if (oneResult != null) {

                 oneResult = chosenFormatType.validateLastCorrect(oneResult.

                         getMatchedRecordTypeId());

                 totalOpportunities += oneResult.getNumOpportunities();

                 totalDefects += oneResult.getNumDefects();

                 for (int defect = 0; defect < oneResult.getNumDefects();

                                   ++defect) {

                     results.append("Line " + record + ":" +

                                    oneResult.getDefectMessage(defect) + "\n");

                 }

                 if (oneResult.getNumDefects() > 0) {

                     addErrorRecord(record);

                 }

             }

             // Summary

             if (progress != null && progress.isCanceled()) {

                 // User cancelled processing

                 results.append(

                         "\n*** User cancelled processing of the file. ***\n");

                 results.insert(0, "Input File: " + fileChosen.getAbsolutePath() +

                                "\nRun Time:" + new Date() +

                                "\nFile Type:" + chosenFormatType.getName() +

                                "\nXML Rules Version:" +

                                chosenFormatType.getVersion() +

                                "\nRecords Read:" + record +

                                "\n*** User cancelled processing of the file. ***\n\n");

             } else {

                 // Processing completed to end of file

                 calc = new SigmaCalculator(totalOpportunities, totalDefects);

                 results.insert(0, "Input File: " + fileChosen.getAbsolutePath() +

                                "\nRun Time:" + new Date() +

                                "\nFile Type:" + chosenFormatType.getName() +

                                "\nXML Rules Version:" +

                                chosenFormatType.getVersion() +

                                "\nRecords Read:" + record +

                                "\nOpportunities:" + totalOpportunities +

                                "\nDefects:" + totalDefects +

                                "\nDPMO:" + calc.getDPMO(0) +

                                "\nSigma:" + calc.getSigma(2) +

                                "\n\n");

             }

         } catch (Throwable any) {

             if (progress == null || !progress.isCanceled()) {

                 results.insert(0, "Error during processing\nError Type: " +

                                any.getClass().getName() + "\nError Message: " +

                                any.getMessage() + "\n\n");

                 logger.error("Error validating content", any);

             }

         } finally {

             appendResult(results.toString());

             resultsDisplay.setCaretPosition(0);

             // Close file, if open

             if (in != null) {

                 try {

                     in.close();

                 } catch (Throwable any) {

                     // Nothing to do

                 }

             }

         }

         setControls();

         setStatusMessage("Records Processed: " + record + "  Total Time: " +

                          Utils.timeElapsedFormat(start, new Date()));

         setCursor(new Cursor(Cursor.DEFAULT_CURSOR));

     }

     /**

      * Save the current results, displayed in the message area, to a file.

      * The user is prompted to enter a file path, using a File-Save dialog.

      */

     private void fileSave() {

         JFileChooser fileChooser;

         File fileToWrite;

         String fileToWritePath;

         String data;

         int returnValue;

         boolean askAgain;

         PrintWriter out;

         BufferedReader in;

         if (fileChosen != null) {

             fileChooser = new JFileChooser(fileChosen.getAbsolutePath());

         } else {

             fileChooser = new JFileChooser();

         }

         do {

             askAgain = false;

             fileToWrite = null;

             fileChooser.setDialogTitle("Save Results");

             fileChooser.setDialogType(JFileChooser.SAVE_DIALOG);

             returnValue = fileChooser.showSaveDialog(this);

             if (returnValue == JFileChooser.APPROVE_OPTION) {

                 fileToWrite = fileChooser.getSelectedFile();

                 if (fileToWrite.exists()) {

                     returnValue = JOptionPane.showConfirmDialog(this,

                             "The file " + fileToWrite.getName() +

                             " already exists.\n\nAre you sure you want to overwrite it?",

                             "File Exists", JOptionPane.YES_NO_CANCEL_OPTION,

                             JOptionPane.QUESTION_MESSAGE);

                     if (returnValue != JOptionPane.YES_OPTION) {

                         fileToWrite = null;

                     }

                     if (returnValue == JOptionPane.NO_OPTION) {

                         askAgain = true;

                     }

                 }

             }

         } while (askAgain);

         if (fileToWrite != null) {

             out = null;

             in = null;

             fileToWritePath = fileToWrite.getAbsolutePath();

             if (!fileToWritePath.toLowerCase().endsWith(".txt")) {

                 fileToWritePath += ".txt";

             }

             try {

                 out = new PrintWriter(new FileWriter(fileToWrite, false));

                 in = new BufferedReader(new StringReader(resultsDisplay.getText()));

                 while ((data = in.readLine()) != null) {

                     out.println(data);

                 }

                 setStatusMessage("Results saved to " + fileToWrite.getName());

             } catch (Throwable any) {

                 JOptionPane.showMessageDialog(this,

                                               "Failed to write file: " +

                                               fileToWrite.getName() +

                                               "\n\nError Type: " +

                                               any.getClass().getName() +

                                               "\nError Msg: " + any.getMessage(),

                                               "Failed to Write File",

                                               JOptionPane.ERROR_MESSAGE);

                 setStatusMessage("Failed to save results");

             } finally {

                 if (out != null) {

                     try {

                         out.close();

                     } catch (Throwable any) {

                         // Nothing to do

                     }

                 }

             }

         }

     }

     /**

      * Print the current results, displayed in the message area.

      */

     private void filePrint() {

         Print printer;

         printer = new Print("Format Check Results");

         printer.print(resultsDisplay.getText());

     }

     /**

      * Copy the selected portion of results display to the clipboard.

      */

     private void copySelectedResults() {

         resultsDisplay.copy();

     }

     /**

      * Select all of the content in the result display.

      */

     private void selectAll() {

         resultsDisplay.selectAll();

     }

     /**

      * Display the sigma calculator

      */

     private void helpSigmaCalc() {

         SigmaCalculatorDialog dialog = new SigmaCalculatorDialog(this);

         dialog.setVisible(true);

     }

     /**

      * Show the application's "About" box.  This should give information including

      * the application name and version.

      */

     private void helpAbout() {

         String slMessage;

         Runtime objlRuntime;

         NumberFormat fmtlNumber;

         fmtlNumber = new DecimalFormat("#,###");

         slMessage = "FormatCheck" + "\nVersion: " + ConstantsInterface.VERSION;

         slMessage += "\n\nFormat Check Tool\n\n";

         slMessage += "David Read\nwww.daveread.us\n\n";

         objlRuntime = Runtime.getRuntime();

         slMessage += "JVM: " + System.getProperty("java.version") + ", " +

                 System.getProperty("java.vendor");

         slMessage += "\nOS: " + System.getProperty("os.name") + ", " +

                 System.getProperty("os.version") + ", " +

                 System.getProperty("os.arch");

         slMessage += "\nMemory: Allocated[" +

                 fmtlNumber.format(objlRuntime.totalMemory()) +

                 "]  Free[" +

                 fmtlNumber.format(objlRuntime.freeMemory()) + "]";

         slMessage += "\nMemory: Max[" + fmtlNumber.format(objlRuntime.maxMemory()) +

                 "]  Allocated[" + fmtlNumber.format(objlRuntime.totalMemory()) +

                 "]  Free[" + fmtlNumber.format(objlRuntime.freeMemory()) + "]";

         slMessage += "\nProcessors: " + objlRuntime.availableProcessors();

         JOptionPane.showMessageDialog(this, slMessage, "About FormatCheck",

                                       JOptionPane.INFORMATION_MESSAGE);

     }

     /**

      * Close the application, disposing of the GUI.

      */

     private void closeApplication() {

         dispose();

         System.exit(0);

     }

     // Begin Interface ActionListener

     public void actionPerformed(ActionEvent evtaWhat) {

         Object objlSource;

         objlSource = evtaWhat.getSource();

         if (objlSource == formatTypeChoice) {

             clearErrorRecords();

             setControls();

         } else if (objlSource == fileNameFileDialogButton) {

             chooseFile();

         } else if (objlSource == runButton) {

             runVerify();

         } else if (objlSource == menuFileSave) {

             fileSave();

         } else if (objlSource == menuFilePrint) {

             filePrint();

         } else if (objlSource == menuFilePrintRecords) {

             filePrintRecords();

         } else if (objlSource == menuFilePrintErrorRecords) {

             filePrintErrorRecords();

         } else if (objlSource == menuFileExit) {

             closeApplication();

         } else if (objlSource == menuEditCopy) {

             copySelectedResults();

         } else if (objlSource == menuEditSelectAll) {

             selectAll();

         } else if (objlSource == menuToolsReloadFormats) {

             setupFormatTypes();

             setStatusMessage("Format definitions reloaded");

         } else if (objlSource == menuToolsSigmaCalculator) {

             helpSigmaCalc();

         } else if (objlSource == menuHelpAbout) {

             helpAbout();

         }

     }

     // End Interface ActionListener

     // Begin Interface WindowListener

     public void windowActivated(WindowEvent evtaWhat) {

     }

     public void windowClosed(WindowEvent evtaWhat) {

     }

     public void windowClosing(WindowEvent evtaWhat) {

         closeApplication();

     }

     public void windowDeactivated(WindowEvent evtaWhat) {

     }

     public void windowDeiconified(WindowEvent evtaWhat) {

     }

     public void windowIconified(WindowEvent evtaWhat) {

     }

     public void windowOpened(WindowEvent evtaWhat) {

     }

     // End Interface WindowListener

     // Begin Runnable Interface

     /**

      * Call the method to verify the input file

      */

     public void run() {

         verifyContent();

     }

     // End Runnable Interface

 }