/*
 * Copyright (c) 2015 Paul Scherrer Institute. All rights reserved.
 */
//<editor-fold defaultstate="collapsed" desc="import"> 
import ch.psi.pshell.core.Controller;
import ch.psi.utils.swing.MonitoredPanel;
import ch.psi.pshell.ui.Panel;
import ch.psi.utils.swing.SwingUtils;
import ch.psi.wsaf.Task;
import java.io.File;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.ImageIcon;
import javax.swing.JPanel;
import javax.swing.table.DefaultTableModel;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Vector;
import java.util.logging.FileHandler;
import java.util.logging.SimpleFormatter;
import javax.swing.DefaultCellEditor;
import javax.swing.JComboBox;
import javax.swing.JDialog;
import javax.swing.JFileChooser;
import javax.swing.table.DefaultTableCellRenderer;
import org.apache.commons.io.FilenameUtils;
import org.python.core.PyList;
import static org.python.bouncycastle.util.Arrays.append;
//</editor-fold>
/**
 *
 * @author boccioli_m
 */
public class TestingList extends Panel {

    NetbeansPluginPanel testingList;

    Task task = new Task() {
        @Override
        protected Object execute() throws Exception {
            return true;
        }
    };

    /**
     *
     * @return
     */
    @Override
    protected JPanel create() {
        try {
            testingList = new NetbeansPluginPanel();

        } catch (IOException ex) {
            Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex);
        }
        return testingList;
    }

    //delete this
    @Override
    protected void onExecutedFile(String fileName, Object result) {
        int iCurrentTestPos = 0;
        try {
            Object ret = eval("ret");
            boolean status = (boolean) eval("status");
            Object deviceName = eval("DEVICE");
            String sStatus = (status == true) ? TestStatus.SUCCESS.toString() : TestStatus.FAILURE.toString();
            System.out.println("onExecutedFile: received end of test for test "+fileName);
//            if (ret != "") {
                //start next test
                if (testingList.isTestRunAllowed() && testingList.runningTestsCount()==0) {
                   // testingList.executeTests(iCurrentTestPos);
                }
/*            } else { // ret empty means that either the test script does not have variable ret, or that the script could not be started at all
                ret = "Could not start test script or script doea not contain default variables";
                sStatus = TestStatus.FAILURE.toString();
                String[] dsDeviceName = testingList.getTestInProgress();
                //SwingUtils.showException(getComponent(), ex );
                if (dsDeviceName[0] != "") {
                    iCurrentTestPos = testingList.showResult(dsDeviceName[0], fileName, ret.toString(), sStatus);
                    //start next test
                    if (testingList.isTestRunAllowed() && testingList.runningTestsCount()==0) {
                        testingList.executeTest(iCurrentTestPos);
                    }
                }
            }
*/        } catch (Exception ex) {
            String ret = "Could not start test script";
            String sStatus = TestStatus.FAILURE.toString();
            String[] dsDeviceName = testingList.getTestInProgress();
            //SwingUtils.showException(getComponent(), ex );
            SwingUtils.showMessage(getComponent(), "onExecutedFile()", ex.toString() + " " + dsDeviceName[0]);
            if (dsDeviceName[0] != "") {
                iCurrentTestPos = testingList.showResult(dsDeviceName[0], fileName, ret, sStatus);
                //start next test
                if (testingList.isTestRunAllowed()) {
                  //  testingList.executeTests(iCurrentTestPos + 1);
                }
            }
        }
    }

    /**
     * enumeration of table column indexes
     */
    public enum COL {

        CHECK(0),
        STARTSEQUENCE(1),
        TIME(2),
        DEVICENAME(3),
        DEVICEDESCR(4),
        TESTSUITE(5),
        TESTNAME(6),
        TESTPATH(7),
        TESTPARAMS(8),
        TESTDESCR(9),
        TESTHELP(10),
        RESULT(11),
        STATUS(12),
        ICON(13);
        private int value;

        private COL(int value) {
            this.value = value;
        }

        /**
         *
         * @return
         */
        public int index() {
            return (int) value;
        }
    };

    /**
     * enumeration of possible test statuses: text and related icon
     */
    public enum TestStatus {

        SUCCESS,
        FAILURE,
        PENDING,
        DISABLED,
        RUNNING;

        /**
         *
         * @return
         */
        public String IconFilename() {
            String iconFileName = "";
            switch (this) {
                case SUCCESS:
                    iconFileName = "/icons/button_ok-16px.png";
                    break;
                case FAILURE:
                    iconFileName = "/icons/button_close-16px.png";
                    break;
                case PENDING:
                    iconFileName = "/icons/button_stop-16px.png";
                    break;
                case DISABLED:
                    iconFileName = "";
                    break;
                case RUNNING:
                    iconFileName = "/icons/button_play-16px.png";
                    break;
            }
            return iconFileName;
        }

        @Override
        public final String toString() {
            String status = "";
            switch (this) {
                case SUCCESS:
                    status = "Success";
                    break;
                case FAILURE:
                    status = "Failure";
                    break;
                case PENDING:
                    status = "Pending";
                    break;
                case DISABLED:
                    status = "Disabled";
                    break;
                case RUNNING:
                    status = "Running";
                    break;
            }
            return status;
        }

        /**
         *
         * @return
         */
        public ImageIcon Icon() {
            String iconFileName = this.IconFilename();
            ImageIcon icon = null;
            if (iconFileName != "") {
                icon = new ImageIcon(getClass().getResource(this.IconFilename()));
            }
            return icon;
        }
    };

    public enum StartSequence {

        START_SEQ_AFTER,
        START_SEQ_TOGETHER;

        @Override
        public final String toString() {
            String status = "";
            switch (this) {
                case START_SEQ_AFTER:
                    status = "After previous";
                    break;
                case START_SEQ_TOGETHER:
                    status = "With previous";
                    break;
            }
            return status;
        }
    };

    /**
     *
     */
    public class NetbeansPluginPanel extends MonitoredPanel {

        Logger logger = Logger.getLogger("TestsLog");
        //these paths are converted to unix or win path according to host OS
        private final String TESTS_DEVICES_DEFAULT_DIR = new java.io.File(".").getCanonicalPath()
                + FilenameUtils.separatorsToSystem("/home/script/tests/devices/");
        private final String TESTS_TESTS_DEFAULT_DIR = new java.io.File(".").getCanonicalPath()
                + FilenameUtils.separatorsToSystem("/home/script/tests/tests/");
        private final String TESTS_LOG_DEFAULT_DIR = new java.io.File(".").getCanonicalPath()
                + FilenameUtils.separatorsToSystem("/home/script/tests/log/TestsLog" + getnow() + ".txt");

        private void initLogger() {
            try {
                FileHandler fh;
                // This block configure the logger with handler and formatter  
                fh = new FileHandler(TESTS_LOG_DEFAULT_DIR);
                logger.addHandler(fh);
                SimpleFormatter formatter = new SimpleFormatter();
                fh.setFormatter(formatter);
                logger.log(Level.INFO, "New testing session");
            } catch (SecurityException e) {
                SwingUtils.showMessage(this, "initLogger()", e.toString());
            } catch (IOException e) {
                SwingUtils.showMessage(this, "initLogger()", e.toString());
            }
        }

        /**
         *
         * @throws IOException
         */
        public NetbeansPluginPanel() throws IOException {
            initComponents();
            initLogger();
            buildTable();
            loadTests();
        }

        @SuppressWarnings("unchecked")

    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        jScrollPane2 = new javax.swing.JScrollPane();
        jTable1 = new javax.swing.JTable();
        jPanel1 = new javax.swing.JPanel();
        jButtonRun = new javax.swing.JButton();
        jButtonOpenLog = new javax.swing.JButton();
        jPanel2 = new javax.swing.JPanel();
        jCheckBox1 = new javax.swing.JCheckBox();
        jButtonMoveDown = new javax.swing.JButton();
        jButtonMoveUp = new javax.swing.JButton();
        jButton1 = new javax.swing.JButton();
        jButton2 = new javax.swing.JButton();

        setLayout(new java.awt.BorderLayout());

        jTable1.setFont(new java.awt.Font("Tahoma", 0, 15)); // NOI18N
        jTable1.setModel(new javax.swing.table.DefaultTableModel(
            new Object [][] {

            },
            new String [] {
                "Select", "Start", "Time", "Device Name", "Device Description", "Test Suite", "Test Name",  "Test Peth", "Test Parameters", "Test Description", "Test Help", "Last Test Result", "Status", ""
            }
        ) {
            Class[] types = new Class [] {
                java.lang.Boolean.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class,  java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class,  java.lang.Object.class, java.lang.Object.class, javax.swing.Icon.class
            };
            boolean[] canEdit = new boolean [] {
                true, true, false, false, false, false, false, false, false,  false,  false, false, false, false
            };

            public Class getColumnClass(int columnIndex) {
                return types [columnIndex];
            }

            public boolean isCellEditable(int rowIndex, int columnIndex) {
                return canEdit [columnIndex];
            }
        });
        jTable1.getTableHeader().setReorderingAllowed(false);
        jTable1.setDragEnabled(true);
        jTable1.setDropMode(javax.swing.DropMode.INSERT);
        jTable1.setRowHeight(22);
        jTable1.addMouseListener(new java.awt.event.MouseAdapter() {
            public void mouseClicked(java.awt.event.MouseEvent evt) {
                jTable1MouseClicked(evt);
            }
        });
        jTable1.addKeyListener(new java.awt.event.KeyAdapter() {
            public void keyReleased(java.awt.event.KeyEvent evt) {
                jTable1KeyReleased(evt);
            }
        });
        jScrollPane2.setViewportView(jTable1);

        add(jScrollPane2, java.awt.BorderLayout.CENTER);

        jPanel1.setMinimumSize(new java.awt.Dimension(100, 100));
        jPanel1.setPreferredSize(new java.awt.Dimension(110, 110));
        jPanel1.setLayout(new java.awt.BorderLayout());

        jButtonRun.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/button_play-64px.png"))); // NOI18N
        jButtonRun.setToolTipText("Run selected tests");
        jButtonRun.setMaximumSize(new java.awt.Dimension(33, 39));
        jButtonRun.setMinimumSize(new java.awt.Dimension(90, 90));
        jButtonRun.setPreferredSize(new java.awt.Dimension(33, 39));
        jButtonRun.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButtonRunActionPerformed(evt);
            }
        });
        jPanel1.add(jButtonRun, java.awt.BorderLayout.CENTER);

        jButtonOpenLog.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/log-icon-64px.png"))); // NOI18N
        jButtonOpenLog.setToolTipText("Open current sessions Log");
        jButtonOpenLog.setMaximumSize(new java.awt.Dimension(80, 39));
        jButtonOpenLog.setMinimumSize(new java.awt.Dimension(90, 90));
        jButtonOpenLog.setPreferredSize(new java.awt.Dimension(90, 39));
        jButtonOpenLog.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButtonOpenLogActionPerformed(evt);
            }
        });
        jPanel1.add(jButtonOpenLog, java.awt.BorderLayout.EAST);

        jPanel2.setLayout(new java.awt.BorderLayout());

        jCheckBox1.setToolTipText("Select/Deselec thet highlighted tests");
        jCheckBox1.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
        jCheckBox1.setHorizontalTextPosition(javax.swing.SwingConstants.CENTER);
        jCheckBox1.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jCheckBox1ActionPerformed(evt);
            }
        });
        jPanel2.add(jCheckBox1, java.awt.BorderLayout.WEST);

        jButtonMoveDown.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/ArrowDown - 24.png"))); // NOI18N
        jButtonMoveDown.setToolTipText("Move the highlighted tests down");
        jButtonMoveDown.setMaximumSize(new java.awt.Dimension(25, 25));
        jButtonMoveDown.setMinimumSize(new java.awt.Dimension(25, 25));
        jButtonMoveDown.setPreferredSize(new java.awt.Dimension(25, 25));
        jButtonMoveDown.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButtonMoveDownActionPerformed(evt);
            }
        });
        jPanel2.add(jButtonMoveDown, java.awt.BorderLayout.SOUTH);

        jButtonMoveUp.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/ArrowUp - 24.png"))); // NOI18N
        jButtonMoveUp.setToolTipText("Move the highlighted tests up");
        jButtonMoveUp.setMaximumSize(new java.awt.Dimension(25, 25));
        jButtonMoveUp.setMinimumSize(new java.awt.Dimension(25, 25));
        jButtonMoveUp.setPreferredSize(new java.awt.Dimension(25, 25));
        jButtonMoveUp.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButtonMoveUpActionPerformed(evt);
            }
        });
        jPanel2.add(jButtonMoveUp, java.awt.BorderLayout.PAGE_START);

        jButton1.setText("jButton1");
        jButton1.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButton1ActionPerformed(evt);
            }
        });
        jPanel2.add(jButton1, java.awt.BorderLayout.CENTER);

        jButton2.setText("jButton2");
        jButton2.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButton2ActionPerformed(evt);
            }
        });
        jPanel2.add(jButton2, java.awt.BorderLayout.LINE_END);

        jPanel1.add(jPanel2, java.awt.BorderLayout.LINE_START);

        add(jPanel1, java.awt.BorderLayout.NORTH);
    }// </editor-fold>//GEN-END:initComponents

    private void jButtonRunActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonRunActionPerformed
        if (this.jButtonRun.getToolTipText().equals("Run selected tests")) {
            setButtonToStart();
            updateStatus();
            executeTests();
        } else {
            setToStopped();
        }
    }//GEN-LAST:event_jButtonRunActionPerformed

        private void setButtonToStop() {
            abort();
            this.jButtonRun.setToolTipText("Run selected tests");
            jButtonRun.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/button_play-64px.png")));
            this.jTable1.setEnabled(true);
        }

        private void setButtonToStart() {
            this.jButtonRun.setToolTipText("Stop tests");
            jButtonRun.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/button_stop-64px.png")));
            this.jTable1.clearSelection();
            this.jTable1.setEnabled(false);
        }


    private void jCheckBox1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jCheckBox1ActionPerformed
        boolean bSelected = jCheckBox1.isSelected();
        int iSelRows = jTable1.getSelectedRowCount();

        if (iSelRows > 0) {// if some rows are selected, check/uncheck selected rows            
            for (int row = 0; row <= jTable1.getRowCount() - 1; row++) {
                for (int selRow = 0; selRow <= jTable1.getSelectedRowCount() - 1; selRow++) {
                    if (row == jTable1.getSelectedRows()[selRow]) {
                        jTable1.setValueAt(bSelected, row, 0);
                    }
                }
            }
        } else {//if none of the rows are selected, check/uncheck all
            for (int row = 0; row <= jTable1.getRowCount() - 1; row++) {
                jTable1.setValueAt(bSelected, row, 0);
            }
        }
        updateStatus();
    }//GEN-LAST:event_jCheckBox1ActionPerformed

    private void jTable1MouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_jTable1MouseClicked
        if(this.jTable1.isEnabled()){
            try {
                switch (evt.getClickCount()) {
                    case 1:
                        int colIndex = jTable1.getSelectedColumn();
                        if (colIndex == COL.CHECK.ordinal()) {
                            updateStatus();
                        }
                        break;
                    case 2:
                        openDetails();
                        break;
                }
            } catch (Exception ex) {
                SwingUtils.showException(this, ex);
            }
        }
    }//GEN-LAST:event_jTable1MouseClicked

        //oopen the log file using one of th default OS text reades
    private void jButtonOpenLogActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonOpenLogActionPerformed
        String cmd;
        if (System.getProperty("os.name").toLowerCase().contains("windows")) {
            cmd = "notepad.exe " + TESTS_LOG_DEFAULT_DIR;
        } else {
            cmd = "nedit " + TESTS_LOG_DEFAULT_DIR;
        }
        try {
            Runtime.getRuntime().exec(cmd);
        } catch (IOException ex) {
            SwingUtils.showMessage(this, "jButtonOpenLogActionPerformed()", "jButtonOpenLogActionPerformed() " + ex.toString()
                    + " \nPlease open the file manually. \nFile dir: " + TESTS_LOG_DEFAULT_DIR);
            Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex);
        }
    }//GEN-LAST:event_jButtonOpenLogActionPerformed

    private void jTable1KeyReleased(java.awt.event.KeyEvent evt) {//GEN-FIRST:event_jTable1KeyReleased
        int colIndex = jTable1.getSelectedColumn();
        if (colIndex == COL.CHECK.ordinal()) {
            updateStatus();
        }
    }//GEN-LAST:event_jTable1KeyReleased

    private void jButtonMoveDownActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonMoveDownActionPerformed
        moveDown();
    }//GEN-LAST:event_jButtonMoveDownActionPerformed

    private void jButtonMoveUpActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonMoveUpActionPerformed
        moveUp();
    }//GEN-LAST:event_jButtonMoveUpActionPerformed

    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton1ActionPerformed

        new Thread(() -> {
            try {
                Object ret = eval("parallelize((run,('testLocalVar1',globals(),{'a':21, 'b':34})), (run,('testLocalVar2',globals(),{'a':231, 'b':234})))");
                //Object ret = eval("parallelize((run,('testLocalVar1',locals= {'a':21, 'b':34})), (run,('testLocalVar2', locals={'a':231, 'b':234})))");
                Object ret1 = ((ArrayList) ret).get(0);
                Object ret2 = ((ArrayList) ret).get(1);
                System.out.println(String.valueOf(ret1));
                System.out.println(String.valueOf(ret2));
            } catch (Exception ex) {
                SwingUtils.showException(this, ex);
            }
        }).start();

    }//GEN-LAST:event_jButton1ActionPerformed

    private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton2ActionPerformed
        // TODO add your handling code here:
        this.loadSettings();
    }//GEN-LAST:event_jButton2ActionPerformed

    //<editor-fold defaultstate="collapsed" desc="Witget Variables declaration"> 
    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JButton jButton1;
    private javax.swing.JButton jButton2;
    private javax.swing.JButton jButtonMoveDown;
    private javax.swing.JButton jButtonMoveUp;
    private javax.swing.JButton jButtonOpenLog;
    private javax.swing.JButton jButtonRun;
    private javax.swing.JCheckBox jCheckBox1;
    private javax.swing.JPanel jPanel1;
    private javax.swing.JPanel jPanel2;
    private javax.swing.JScrollPane jScrollPane2;
    private javax.swing.JTable jTable1;
    // End of variables declaration//GEN-END:variables
    //</editor-fold> 

        /**
         *
         * @return status of run button. True = tests launching sequence is
         * running
         */
        public boolean isTestRunAllowed() {
            return (this.jButtonRun.getToolTipText().equals("Stop tests") && pendingTestsCount()>0);
        }

        //move selection up in table
        private void moveUp() {
            DefaultTableModel model = (DefaultTableModel) jTable1.getModel();
            int[] rows = jTable1.getSelectedRows();
            if (rows[0] - 1 >= 0) {
                jTable1.setAutoCreateRowSorter(false);
                model.moveRow(rows[0], rows[rows.length - 1], rows[0] - 1);
                jTable1.setAutoCreateRowSorter(true);
                jTable1.setRowSelectionInterval(rows[0] - 1, rows[rows.length - 1] - 1);
            }
        }

        //move selection down in table
        private void moveDown() {
            DefaultTableModel model = (DefaultTableModel) jTable1.getModel();
            int[] rows = jTable1.getSelectedRows();
            if (rows[rows.length - 1] < jTable1.getRowCount()) {
                jTable1.setAutoCreateRowSorter(false);
                model.moveRow(rows[0], rows[rows.length - 1], rows[0] + 1);
                jTable1.setAutoCreateRowSorter(true);
                jTable1.setRowSelectionInterval(rows[0] + 1, rows[rows.length - 1] + 1);
            }
        }

        //open details of the selected test in a new panel
        private void openDetails() throws Exception {
            //pick details from the clicked row
            int row = jTable1.getSelectedRow();
            String sDeviceName = jTable1.getValueAt(row, COL.DEVICENAME.ordinal()).toString();
            String sTestName = jTable1.getValueAt(row, COL.TESTNAME.ordinal()).toString();
            String sTestPath = String.valueOf(jTable1.getValueAt(row, COL.TESTPATH.ordinal()));
            String sTestCaseName = jTable1.getValueAt(row, COL.TESTSUITE.ordinal()).toString();
            String sTestDescription = jTable1.getValueAt(row, COL.TESTDESCR.ordinal()).toString();
            String sDeviceDescription = jTable1.getValueAt(row, COL.DEVICEDESCR.ordinal()).toString();
            String sLastResult = jTable1.getValueAt(row, COL.RESULT.ordinal()).toString();
            String sResultTime = jTable1.getValueAt(row, COL.TIME.ordinal()).toString();
            String sTestHelp = String.valueOf(jTable1.getValueAt(row, COL.TESTHELP.ordinal()));
            HashMap mParameters = buildParametersMap(String.valueOf(jTable1.getValueAt(row, COL.TESTPARAMS.ordinal())));
            //create map for passing details to Details Panel
            HashMap details = new HashMap();
            details.put("deviceName", sDeviceName);
            details.put("deviceDescription", sDeviceDescription);
            details.put("testDescription", sTestDescription);
            details.put("testSuite", sTestCaseName);
            details.put("testName", sTestName);
            details.put("testResult", sLastResult);
            details.put("time", sResultTime);
            details.put("parameters", mParameters);
            details.put("testHelp", sTestHelp);
            details.put("testPath", sTestPath);
            //open details panel
            JDialog dlg = new JDialog(getView(), "Test Details - " + sTestName, true);
            //create a class to visualise the details panel
            Class testingListDetailsClass = getController().getClassByName("TestingListDetails");
            JPanel detailsPanel = (JPanel) testingListDetailsClass.getConstructor(new Class[]{HashMap.class}).newInstance(new Object[]{details});

            dlg.getContentPane().add(detailsPanel);
            //dlg.add(new TestingListDetails());
            dlg.pack();
            dlg.setVisible(true);
        }

        /**
         * show test result in table
         *
         * @param deviceName
         * @param testName
         * @param res
         * @param status
         * @return
         */
        public int showResult(String deviceName, String testName, String res, String status) {
            int rowD = -1;
            String sTestName = testName;
            logger.log(Level.FINE, "Looking for: deviceName: " + deviceName + "; testPath: " + testName + " in table.");
            String sStatus;
            if(status == "true"){
                sStatus = TestStatus.SUCCESS.toString();
            } else if (status == "false"){
                sStatus = TestStatus.FAILURE.toString();
            } else{
                sStatus = status;
            }
            //search for device name in table
            for (int row = 0; row <= jTable1.getRowCount() - 1; row++) {
                if (deviceName.equals(jTable1.getValueAt(row, COL.DEVICENAME.ordinal()))
                        && testName.equals(jTable1.getValueAt(row, COL.TESTPATH.ordinal()))) {
                    rowD = row;
                    sTestName = jTable1.getValueAt(rowD, COL.TESTNAME.ordinal()).toString();
                    break;
                }
            }
            ImageIcon icon = new ImageIcon();
            switch (sStatus) {
                case "Success":
                    icon = TestStatus.SUCCESS.Icon();
                    logger.log(Level.INFO, sStatus + " - Device: " + deviceName + "; Test: " + sTestName + "; Result: " + res);
                    break;
                case "Failure":
                    icon = TestStatus.FAILURE.Icon();
                    logger.log(Level.SEVERE, sStatus + " - Device: " + deviceName + "; Test: " + sTestName + "; Result: " + res);
                    break;
                case "Running":
                    icon = TestStatus.RUNNING.Icon();
                    //logger.log(Level.INFO, "Running Test: " + sTestName + ".");
                    break;
            }
            if (rowD >= 0) {
                jTable1.setValueAt(icon, rowD, COL.ICON.ordinal());
                jTable1.setValueAt(getNow(), rowD, COL.TIME.ordinal());
                jTable1.setValueAt(res, rowD, COL.RESULT.ordinal());
                jTable1.setValueAt(sStatus, rowD, COL.STATUS.ordinal());
            } else {
                logger.log(Level.SEVERE, "Cant find Test: " + testName + " in table.");
            }
            //check if there are still pending tests. If not, set the status of the tool to Stopped.
            if (pendingTestsCount()==0 && runningTestsCount()==0) {
                setToStopped();
            } 
            return rowD;
        }
        
        //returns the amount of tests currently in Pending state
        public int pendingTestsCount(){                        
            return testsStatusCount(TestStatus.PENDING);    
        }
        
        //returns the amount of tests currently in Pending state
        public int runningTestsCount(){                        
            return testsStatusCount(TestStatus.RUNNING);    
        }
        
        //returns the amount of tests currently in Pending state
        public int successTestsCount(){                        
            return testsStatusCount(TestStatus.SUCCESS);    
        }        

          //returns the amount of tests currently in "status" state
        private int testsStatusCount(TestStatus status){                        
            String sStatus;
            boolean bSelected;
            int iPendingTestsCount = 0;
            for (int row = 0; row < jTable1.getRowCount(); row++) {
                bSelected = (boolean) jTable1.getValueAt(row, COL.CHECK.ordinal());
                sStatus = jTable1.getValueAt(row, COL.STATUS.ordinal()).toString();
                if(bSelected && sStatus == status.toString()){
                    iPendingTestsCount++;
                }
            }
            return iPendingTestsCount;    
        }
        
        private void setToStopped(){
              //No more tests to play. Stop 
            setButtonToStop();
            logger.log(Level.INFO, "End of tests.");           
        }
        
        /**
         * find the test currently in progress
         *
         * @return properties of the test in progress
         */
        public String[] getTestInProgress() {
            String[] dsTestProperties = {"", ""};
            //search for device name in table
            try {
                for (int row = 0; row <= jTable1.getRowCount() - 1; row++) {
                    if (jTable1.getValueAt(row, COL.STATUS.ordinal()).toString().equals(TestStatus.RUNNING.toString())) {
                        dsTestProperties[0] = jTable1.getValueAt(row, COL.DEVICENAME.ordinal()).toString();
                        dsTestProperties[1] = jTable1.getValueAt(row, COL.TESTPATH.ordinal()).toString();
                        break;
                    }
                }
            } catch (Exception ex) {
                this.setToStopped();
                SwingUtils.showMessage(this, "getTestInProgress()", ex.toString());
            } finally {
                return dsTestProperties;
            }
        }

        //returns the status of the specified test name for specified device name
        public String getResult(String deviceName, String testName) {
            String sStatus = "";
            int rowD = -1, colT = -1;
            //search for device name in table
            for (int row = 0; row <= jTable1.getRowCount() - 1; row++) {
                if (deviceName.equals(jTable1.getValueAt(row, COL.DEVICENAME.ordinal()))) {
                    rowD = row;
                    break;
                }
            }
            if (rowD >= 0) {
                //search for test name in table
                if (testName.equals(jTable1.getValueAt(rowD, COL.TESTPATH.ordinal()))) {
                    colT = COL.TESTNAME.ordinal();
                }
            }
            if (colT >= 0 && rowD >= 0) {
                sStatus = jTable1.getValueAt(rowD, COL.STATUS.ordinal()).toString();
            }
            return sStatus;
        }

        /**
         * visualise test status (columns status and icon)
         */
        public void updateStatus() {
            String sStatus;
            boolean bSelected;
            ImageIcon icon = null;
            String sStart;
            for (int row = 0; row <= jTable1.getRowCount() - 1; row++) {
                bSelected = (boolean) jTable1.getValueAt(row, COL.CHECK.ordinal());
                sStart = String.valueOf(jTable1.getValueAt(row, COL.STARTSEQUENCE.ordinal()));
                if (bSelected) {
                    sStatus = TestStatus.PENDING.toString();
                    icon = TestStatus.PENDING.Icon();
                    if (sStart == "") {
                        sStart = StartSequence.START_SEQ_AFTER.toString();
                    }
                } else {
                    sStatus = TestStatus.DISABLED.toString();
                    icon = TestStatus.DISABLED.Icon();
                    sStart = "";
                }
                jTable1.setValueAt(bSelected, row, COL.CHECK.ordinal());
                jTable1.setValueAt(icon, row, COL.ICON.ordinal());
                jTable1.setValueAt(sStatus, row, COL.STATUS.ordinal());
                jTable1.setValueAt(sStart, row, COL.STARTSEQUENCE.ordinal());
            }
        }
        
        public void executeTests(){
                RunTest runTest = new RunTest();
                Thread t = new Thread(runTest);
                t.start();        
        }

        public class RunTest implements Runnable {

            private HashMap mParameters;
            //private HashMap<String,Object> args;
            private HashMap<String,HashMap> hTests;
            
            public RunTest() {
                //System.out.println("A0");
            }
            
            public void run() {
                // code in the other thread, can reference "var" variable
                executeTest(0);
            }
            
        //execute the selected tests in the list, starting from the position
        private void executeTest(int position) {
            boolean bSelected = false;
            String sStartSequence, sStatus;
            int[] selectedTestsRows = {};
            //scan through the table starting from 'position' and execute the first selected test found
            int row = 0;// position;
            if (row >= 0 && row < jTable1.getRowCount()) {
                for (row = position; row < jTable1.getRowCount(); row++) {
                    bSelected = (boolean) jTable1.getValueAt(row, COL.CHECK.ordinal());
                    sStartSequence = jTable1.getValueAt(row, COL.STARTSEQUENCE.ordinal()).toString();
                    sStatus = jTable1.getValueAt(row, COL.STATUS.ordinal()).toString();
                    //collect tests to be launched in parallel
                    //the test must be: selected, set as start with previous, pending.
                    //alternatively, the test must be: selected, first of the list.

                    //System.out.println(String.valueOf(row) + "\t" + String.valueOf(bSelected) + "\t" + String.valueOf(selectedTestsRows.length) + "\t" + sStartSequence + "\t" + sStatus);

                    if (bSelected
                                    && sStatus.equals(TestStatus.PENDING.toString())
                                    && (selectedTestsRows.length == 0 || //the test must be: selected, pending, first of the list.
                                    sStartSequence.equals(StartSequence.START_SEQ_TOGETHER.toString()))) { //or the test must be: selected, pending, set as start with previous
                        selectedTestsRows = append(selectedTestsRows, row);
                    } else if (bSelected
                                    && sStatus.equals(TestStatus.PENDING.toString()) &&//if this test must be executed...
                                    selectedTestsRows.length > 0 && //but there are already tests to be executed in parallel....
                                    (sStartSequence.equals(StartSequence.START_SEQ_AFTER.toString()))) { //...and this test must be executed in series, then stop searching
                        break;
                    }
                }
                if (selectedTestsRows.length > 0) { //at least one test is selected: launch it (or them)
                        System.out.println("\n===================================================\n");
                        executeParallelTestsGroup(selectedTestsRows) ; //last execution did not find a test file. Continue with next execution
                        executeTest(position + 1);
                    
                }
            } 
        }

        private HashMap buildMapFromTableRow(int row){
                String sDeviceName = jTable1.getValueAt(row, COL.DEVICENAME.ordinal()).toString();
                String sTestName = jTable1.getValueAt(row, COL.TESTNAME.ordinal()).toString();
                String sTestCaseName = jTable1.getValueAt(row, COL.TESTSUITE.ordinal()).toString();
                String sTestPath = jTable1.getValueAt(row, COL.TESTPATH.ordinal()).toString();
                HashMap mParameters = buildParametersMap(String.valueOf(jTable1.getValueAt(row, COL.TESTPARAMS.ordinal())));           
                HashMap testArgs = new HashMap();
                    //args.put("ret", "");
                testArgs.put("parameters", mParameters);
                testArgs.put("test", sTestName);
                testArgs.put("device", sDeviceName);
                testArgs.put("testPath", sTestPath);          
                testArgs.put("status", false);          
                
                return testArgs;
        }

        //start all the tests in the rowsToExecute
        private int executeParallelTestsGroup(int[] rowsToExecute) {
            int iRet = -1;
            HashMap args2 = new HashMap(); //this is the global map that will contain one map per test.
            HashMap testArgs; //this is the map for a test.
            RunTest runTest;
            String sTestName="", sDeviceName="", sTestPath="";
            for (int row : rowsToExecute) {
                //System.out.println(String.valueOf(row) + "\t" + sDeviceName + "\t" + sTestName + "\t" + sTestCaseName + "\t" + String.valueOf(rowsToExecute.length));
                try {
                    testArgs = buildMapFromTableRow(row);
                    sTestName = (String) testArgs.get("test") ;
                    sTestPath = (String) testArgs.get("testPath") ;
                    sDeviceName = (String) testArgs.get("device") ;
                    mParameters = (HashMap) testArgs.get("parameters") ; 
                    File f = new File(sTestPath);
                    if (!f.exists() || f.isDirectory()) {
                        logger.log(Level.SEVERE, "Cannot find test script: " + sTestPath);
                        showResult(sDeviceName, sTestPath, "Cannot find test script: " + sTestPath, TestStatus.FAILURE.toString());
                        continue;
                    }
                    showResult(sDeviceName, sTestPath, "Test running", TestStatus.RUNNING.toString());
                    //launch the test
                    if (!mParameters.isEmpty()) {
                        logger.log(Level.INFO, "Running test '" + sTestName + "' with the following parameters: " + mParameters.toString());
                        System.out.println("Running test '" + sTestName + "' with the following parameters: " + mParameters.toString());
                    } else {
                        logger.log(Level.INFO, "Running Test '" + sTestName + "'. No parameters found.");
                        System.out.println("Running test '" + sTestName + "'. No parameters found.");
                    }

                    args2.put(sTestPath,testArgs);
                    
                    hTests = args2;
                    iRet = 0;
                } catch (Exception ex) {
                    SwingUtils.showMessage(TestingList.this.getComponent(), "executeTest()", ex.toString());
                    logger.log(Level.SEVERE, ex.toString());
                    showResult(sDeviceName, sTestPath, ex.toString(), TestStatus.FAILURE.toString());
                    setToStopped();
                }
            }
            try{
                int iLastExecutedTestIndex = -1;
                final String sParallelizeBegin = "(run,(str('";
                final String sParallelizeEnd   = "'),))";
                String sParallelizeArguments;
                try {
                    //System.out.println("A0.1");                   
                    String sParallelizeCommand = "parallelize(";
                    int i = 0;
                    int iTotalEntries = hTests.entrySet().size();
                    for(Map.Entry<String, HashMap> hTest : hTests.entrySet()){
                        //setGlobalsVars(hTest.getValue()); //set global variables that can be read by all test scripts
                        sTestPath =  hTest.getKey().toString();
                        sTestPath = sTestPath.replace("\\","\\\\");
                        //System.out.println(hTest.getValue().get("test"));
                        sParallelizeCommand = sParallelizeCommand + "(run,(str('" + sTestPath;
                        //System.out.println("Parameters passed: " + String.valueOf(hTest.getValue().get("parameters")));
                        //System.out.println("A"+i);
                        sParallelizeArguments = "globals(),{'parameters':'"+hTest.getValue().get("parameters")+
                                                    "','test':'"+hTest.getValue().get("test")+
                                                    "','device':'"+hTest.getValue().get("device")+
                                                    "','status':'"+hTest.getValue().get("status")+"'}";
                        //sParallelizeArguments = "locals()";
                        sParallelizeCommand = sParallelizeCommand +
                                                    "'),"+sParallelizeArguments;
                        i++;
                        if (i<iTotalEntries){
                            sParallelizeCommand = sParallelizeCommand +")),"; //between each "run" command
                        }else{
                            sParallelizeCommand = sParallelizeCommand +")))"; //very last part of command "parallelize"
                        }
                    }
                    System.out.println(sParallelizeCommand);
                    Object ret = eval("globals()");
                    ret = eval("locals()");
                    ret = eval(sParallelizeCommand);
//                    Object ret = eval("parallelize((run,(str('"+sTestPath+"'),)), (run,('Motor Test 3 200ms',)))");
                    //System.out.println("Ret = " + String.valueOf(ret));
                    String sTestResult, sTestStatus;
                    //read the return mapping and put the result in the right table row
                    //System.out.println("ret type "+ret.getClass().toString() );
                    //scan through all return mappings of all run tests
                    for(Object oTestRet : (ArrayList) ret){            
                        //check if the mapping of the selected test has all expected return values
                        if(((List<PyList>) oTestRet).size()>=4){
                            //extract return data of the current test
                            sTestPath   = String.valueOf(((List<PyList>) oTestRet).get(0));
                            sDeviceName = String.valueOf(((List<PyList>) oTestRet).get(1));
                            sTestResult = String.valueOf(((List<PyList>) oTestRet).get(2));
                            sTestStatus = String.valueOf(((List<PyList>) oTestRet).get(3));
                            //from the map of executed tests, get the test name (key is test path)
                            HashMap<String, HashMap> hTest = hTests.get(sTestPath);
                            sTestName =   String.valueOf(hTest.get("test"));
                        } else{ //problem, the test script does not return all the expected return values
                            String sErrorText = "Test "+ sTestPath+" did not return all required return values";
                            Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, sErrorText);
                            SwingUtils.showMessage(TestingList.this.getComponent(), "executeParallelTestsGroup()", sErrorText);
                            System.out.println(String.valueOf(sErrorText));
                            //try to fetch at least first element of returned map. If fails, it will go to catch
                            sTestPath   = String.valueOf(((List<PyList>) oTestRet).get(0));
                            sTestStatus = sErrorText;
                            sTestResult = "false";
                            HashMap<String, HashMap> hTest = hTests.get(sTestPath);
                            sDeviceName = String.valueOf(hTest.get("device"));
                            sTestName =   String.valueOf(hTest.get("test"));                
                        }   
                        System.out.println("Result: " + sDeviceName + "|" + sTestPath + "|" + sTestResult + "|" + sTestStatus);
                        iLastExecutedTestIndex = showResult(sDeviceName, sTestPath, sTestResult, sTestStatus) ;                        
                    }                 
                } catch (ClassCastException ccex) {
                    Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ccex);
                    SwingUtils.showMessage(TestingList.this.getComponent(), "executeParallelTestsGroup()", ccex.toString());
                    //System.out.println(String.valueOf(ccex));
                    if(!sDeviceName.isEmpty())
                        showResult(sDeviceName, sTestPath, ccex.toString(), TestStatus.FAILURE.toString());
                } catch (Exception ex) {
                    Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex);
                    SwingUtils.showMessage(TestingList.this.getComponent(), "executeParallelTestsGroup()", ex.toString());
                    System.out.println(String.valueOf(ex));
                    showResult(sDeviceName, sTestPath, ex.toString(), TestStatus.FAILURE.toString());
                }                
             
                
            }       catch (Exception ex) {
                    SwingUtils.showMessage(TestingList.this.getComponent(), "executeParallelTestsGroup(), run thread", ex.toString());
                    logger.log(Level.SEVERE, ex.toString());
                    setToStopped();
            }            
            return iRet;
        }   
        }


        /**
         * table management
         */
        private void buildTable() {
            String sDate = getNow();
            DefaultTableModel model = (DefaultTableModel) jTable1.getModel();
            jTable1.setModel(model);

            //Set up the combo box editor for the Start Sequence cells.
            JComboBox comboBox = new JComboBox();
            comboBox.addItem(StartSequence.START_SEQ_AFTER.toString());
            comboBox.addItem(StartSequence.START_SEQ_TOGETHER.toString());
            jTable1.getColumnModel().getColumn(COL.STARTSEQUENCE.ordinal()).setCellEditor(new DefaultCellEditor(comboBox));
            //Set up tool tips for the sequence cells.
            DefaultTableCellRenderer renderer = new DefaultTableCellRenderer();
            renderer.setToolTipText("Click for options");
            jTable1.getColumnModel().getColumn(COL.STARTSEQUENCE.ordinal()).setCellRenderer(renderer);

            jTable1.getColumnModel().getColumn(COL.ICON.ordinal()).setMaxWidth(27);
            jTable1.getColumnModel().getColumn(COL.CHECK.ordinal()).setMaxWidth(27);
            jTable1.getColumnModel().getColumn(COL.DEVICENAME.ordinal()).setPreferredWidth(30);
            jTable1.getColumnModel().getColumn(COL.STATUS.ordinal()).setPreferredWidth(30);
            hideColumn(COL.DEVICEDESCR);
            hideColumn(COL.TESTPATH);
            hideColumn(COL.TESTDESCR);
            hideColumn(COL.TESTPARAMS);
            hideColumn(COL.TESTHELP);
            jTable1.setAutoCreateRowSorter(true);
            updateStatus();
        }

        private void hideColumn(COL column) {
            jTable1.getColumnModel().getColumn(column.ordinal()).setMinWidth(0);
            jTable1.getColumnModel().getColumn(column.ordinal()).setMaxWidth(0);
        }

        //append test info to table
        private void addToTable(String deviceName,
                String deviceDescription,
                String testSuite,
                String testName,
                String testParams,
                String testDescription,
                String testHelp) {
            String sDate = "";
            if (testName.equals("") || deviceName.equals("")) {
                return;
            }
            ImageIcon icon = null;// new ImageIcon(getClass().getResource("/icons/button_pause-16px.png"));
            DefaultTableModel model = (DefaultTableModel) jTable1.getModel();
            String testPath = FilenameUtils.separatorsToSystem(TESTS_TESTS_DEFAULT_DIR + testSuite + "/" + testName + "/" + testName + ".py");
            model.addRow(new Object[]{false, "", sDate, deviceName, deviceDescription, testSuite, testName, testPath, testParams, testDescription, testHelp, "", "Pending", icon});
            jTable1.setModel(model);
            updateStatus();
        }

        /**
         *
         * @return formatted time
         */
        public String getNow() {
            DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
            Date date = new Date();
            return dateFormat.format(date);
        }

        /**
         *
         * @return time with sortable format
         */
        public String getnow() {
            DateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
            Date date = new Date();
            return dateFormat.format(date);
        }

        //scan tests directory, scan devices directory, search for their test cases and scan for tests.
        public void loadTests() throws FileNotFoundException, IOException {
            Properties propDevice = new Properties();
            Properties propTest = new Properties();
            String fileName = TESTS_DEVICES_DEFAULT_DIR;
            File folder = new File(fileName);
            File testsFolder = null;
            String sTestName;
            int iCounter = 0;
            //search devices and their tests
            //Scan the list of devices
            File[] listOfFiles = folder.listFiles();
            for (File listOfFile : listOfFiles) {
                propDevice.clear();
                if (listOfFile.isFile()) {
                } else if (listOfFile.isDirectory()) {
                    File configFile = new File(listOfFile.getPath() + FilenameUtils.separatorsToSystem("/.config"));
                    if (configFile.exists() && !configFile.isDirectory()) {
                        InputStream is = new FileInputStream(configFile);
                        propDevice.load(is);
                        //config of device was loaded. now load the config of each test belonging to the device
                        sTestName = TESTS_TESTS_DEFAULT_DIR + propDevice.getProperty("tests");
                        testsFolder = new File(sTestName);
                        if (testsFolder.exists() && testsFolder.isDirectory()) {
                            File[] listOfTests = testsFolder.listFiles();
                            for (File listOfTest : listOfTests) {
                                propTest.clear();
                                if (listOfTest.isDirectory()) {
                                    configFile = new File(listOfTest.getPath() + FilenameUtils.separatorsToSystem("/.config"));
                                    if (configFile.exists() && !configFile.isDirectory()) {
                                        InputStream ist = new FileInputStream(configFile);
                                        propTest.load(ist);
                                        addToTable(propDevice.getProperty("name"),
                                                propDevice.getProperty("description"),
                                                propDevice.getProperty("tests"),
                                                propTest.getProperty("name"),
                                                propTest.getProperty("parameters"),
                                                propTest.getProperty("description"),
                                                propTest.getProperty("help"));
                                        iCounter++;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            logger.log(Level.INFO, iCounter + " tests loaded.");
        }

        /**
         * Build a map with optional parameters to be passed to the testing
         * script. The map is like this: parameters | \_ name | | | \_ value |
         * \_ description | \_ name | | | \_ value | \_ description ... the name
         * 'name' is the mapping key. 'value' and 'description' are constant
         * mapping keys of a nested map.
         */
        private HashMap buildParametersMap(String parametersString) {
            HashMap mParameters = new HashMap(); // contains name and attributes
            HashMap mParameterAttributes = new HashMap(); //contians value and description
            String[] dsParameterAttributes = null;
            String[] dsParameters = parametersString.split(";");
            for (String sParameter : dsParameters) {
                dsParameterAttributes = sParameter.split(":");
                if (dsParameterAttributes.length > 2) {
                    mParameterAttributes = new HashMap();
                    mParameterAttributes.put("value", (Object) dsParameterAttributes[1]);
                    mParameterAttributes.put("description", dsParameterAttributes[2]);
                    //add parameter name and attributes (value + description)
                    mParameters.put(dsParameterAttributes[0], mParameterAttributes);
                }
            }
            return mParameters;
        }

        /**
         *
         */
        public void selectFile() {
            final JFileChooser fc = new JFileChooser();

            int returnVal = fc.showOpenDialog(NetbeansPluginPanel.this);

            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = fc.getSelectedFile();
                //This is where a real application would open the file.
                System.out.println("Opening: " + file.getName() + ".");
            } else {
                System.out.println("Open command cancelled by user.");
            }
        }

        private void saveSettings() {
            final JFileChooser fc = new JFileChooser();

            int returnVal = fc.showOpenDialog(NetbeansPluginPanel.this);

            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = fc.getSelectedFile();
                saveSettings(file);
            }
        }

        private void saveSettings(File file) {
            DefaultTableModel tableModel = (DefaultTableModel) jTable1.getModel();
            try {
                ObjectOutputStream out = new ObjectOutputStream(
                        new FileOutputStream(file));
                out.writeObject(tableModel.getDataVector());
                out.close();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }

        private void loadSettings() {
            final JFileChooser fc = new JFileChooser();
            int returnVal = fc.showOpenDialog(NetbeansPluginPanel.this);
            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = fc.getSelectedFile();
                loadSettings(file);
            }
        }

        private void loadSettings(File file) {
            DefaultTableModel tableModel = (DefaultTableModel) jTable1.getModel();
            try {
                ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
                Vector rowData = (Vector) in.readObject();
                Iterator itr = rowData.iterator();
                for (int row = 0; row < jTable1.getRowCount(); row++) {
                    tableModel.removeRow(row);
                }
                while (itr.hasNext()) {
                    tableModel.addRow((Vector) itr.next());
                }
                in.close();
            } catch (Exception ex) {
                ex.printStackTrace();
                SwingUtils.showMessage(this, "loadSettings()", ex.toString());
            }
        }

        //end of class
    }
}