DaqPanel.java

Go to the documentation of this file.

package dndtester;
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;


public class DaqPanel extends JPanel{
    boolean isConnected = false;
    
    DaqTests daqTests;
    
    static DaqPanel curDaqPanel;
    
    JRootPane rootPane;
    
    JScrollBar scroller;
    
    ConnectionPanel connectPanel;
    
    TestPanel testPanel;
    
    final SSPanel sspanel;
    ResetDebugPanel rDPanel;
    
    Hashtable openPorts;

    class ConnectionPanel extends JPanel{
        public static final int MAXTEXT = 15;
        
        public static final int PORTTEXT = 5;
        
        JButton connection;
        
        JButton disconnect;
        
        JLabel daqMachine;
        
        JLabel labelComPort;
        
        JTextField daqServer;
        
        JTextField commandPort;
        
        JLabel connectStat;

        public ConnectionPanel(){
            // All variables are initialized to default values.
            connectStat = new JLabel("offline      ");
            connectStat.setForeground(Color.red);
            labelComPort = new JLabel("Command Port");
            commandPort = new JTextField(PORTTEXT);
            commandPort.setHorizontalAlignment(JTextField.RIGHT);
            commandPort.setText("55055");
            daqMachine = new JLabel("DAQ Machine");
            daqServer = new JTextField(MAXTEXT);
            daqServer.setText("localhost");
            connection = new JButton("Connect");
            disconnect = new JButton("Disconnect");

            setLayout(new FlowLayout());
            
            // Must be added in the correct order to display correctly, 
            // added from left to right.            
            add(connectStat);
            add(labelComPort);
            add(commandPort);
            add(daqMachine);
            add(daqServer);
            add(connection);
            add(disconnect);
        }
    }
    
    class TestPanel extends JPanel{
        JTextField commandText;
        JTextField resultText;
        
        JLabel commandLabel;
        
        JLabel resultLabel;
        
        JButton commandTestB;
        
        JLabel dataNumLabel;
        
        JTextField readDataNum;
        
        JTextField suiteRuns;
        
        JButton readDataB;

        JButton testSuiteB;
        
        JLabel suiteRunsL;

        public TestPanel(){
            GridBagLayout gbl = new GridBagLayout();
            GridBagConstraints gbc = new GridBagConstraints();
            setLayout(gbl);
            commandText = new JTextField(10);
            resultText = new JTextField(10);
            commandTestB = new JButton("Test");
            commandLabel = new JLabel("Command to test: ");
            resultLabel = new JLabel("Known result");
            dataNumLabel = new JLabel("Times to read Data: ");
            readDataNum = new JTextField(4);
            readDataNum.setHorizontalAlignment(JTextField.RIGHT);
            readDataNum.setText("1");
            readDataB = new JButton("Read Data");
            testSuiteB = new JButton("Run DAQ test suite");
            suiteRunsL = new JLabel("Test Runs: ");
            suiteRuns = new JTextField(3);

            suiteRuns.setHorizontalAlignment(JTextField.RIGHT);
            suiteRuns.setText("1");
            
            gbc.gridwidth = GridBagConstraints.REMAINDER;
            gbc.anchor = GridBagConstraints.WEST;
            gbc.insets = new Insets(0,15,0,5);
            
            // Adding components to the Panel where inserts are the spacing.
            add(commandLabel,gbc);
            add(commandText,gbc);
            add(resultLabel,gbc);
            add(resultText,gbc);

            gbc.insets = new Insets(0,40,5,0);
            add(commandTestB,gbc);

            gbc.insets = new Insets(0,10,0,5);
            add(dataNumLabel,gbc);

            gbc.insets = new Insets(0,50,0,5);
            add(readDataNum,gbc);

            gbc.insets = new Insets(0,22,5,0);
            add(readDataB, gbc);

            gbc.insets = new Insets(0,25,5,0);
            gbc.gridwidth = 1;
            add(suiteRunsL,gbc);

            gbc.gridwidth = GridBagConstraints.REMAINDER;
            add(suiteRuns,gbc);
            gbc.insets = new Insets(0,0,0,0);
            add(testSuiteB,gbc);
        }
    }
    
    class ResetDebugPanel extends JPanel{

        JButton reset = new JButton("reset");

        JButton resetAll = new JButton("reset All");

        JCheckBox debugInfo;

        JCheckBox showDebugInf;

        public ResetDebugPanel(){
            GridBagLayout gbl = new GridBagLayout();
            GridBagConstraints gbc = new GridBagConstraints();
            setLayout(gbl);
            reset = new JButton("reset");
            resetAll = new JButton("reset All");
            debugInfo = new JCheckBox("Log debugging Info");
            showDebugInf = new JCheckBox("Show debugging Info");
            gbc.insets = new Insets(0,0,0,80);            
            add(resetAll, gbc);
            gbc.insets = new Insets(0,0,0,50);            
            add(debugInfo,gbc);
            gbc.insets = new Insets(0,0,0,75);            
            add(showDebugInf,gbc);
            add(reset);
        }

    }
    public void paint(Graphics graphics){
        Dimension pref = sspanel.getPreferredSize();
        Dimension size = sspanel.getSize();
        int extent = size.height, max = pref.height;
        int value = Math.max(0, Math.min(scroller.getValue(), max - extent));
        scroller.setVisible(extent < max);
        scroller.setUnitIncrement(sspanel.getUnitHeight());
        scroller.setBlockIncrement(extent - scroller.getUnitIncrement());
        scroller.setValues(value, extent, 0, max);
        super.paint(graphics);
    }
    public DaqPanel(JRootPane root){
        rootPane = root;
        
        // Variables for GridBagLayout
        GridBagLayout gbl= new GridBagLayout();
        
        // Used to set all GridBagConstraints.
        GridBagConstraints gbc = new GridBagConstraints();
        setLayout(gbl);
        curDaqPanel = this;
        
        //the JRootPane cannot be null.
        if(root == null){
            System.out.println("ERROR abnormar execution");
            System.exit(0);
        }
        
        openPorts = new Hashtable();

        //connectPanel is the first one to be initialized and added to the DaqPanel
        connectPanel = new ConnectionPanel();
        //the following constrains force the connectPanel to be located on top.
        gbc.anchor = GridBagConstraints.WEST;
        gbc.gridwidth = GridBagConstraints.REMAINDER;
        //gbc.weightx = 1.0;
        gbc.fill = GridBagConstraints.HORIZONTAL;
        add(connectPanel, gbc);
        
        //testPanel is initialized and added to the DaqPanel
        testPanel = new TestPanel();
        //the following constains force the testPanel to be located on the right.
        gbc.fill = GridBagConstraints.NONE;
        gbc.gridwidth = 1;
        //gbc.weightx = 0.0;
        gbc.insets = new Insets(0,15,0,0);
        add(testPanel, gbc);
        
        
        sspanel = new SSPanel();
        sspanel.setLayout(new BorderLayout());

        //a scroller is created and added to the sspanel
        scroller = new JScrollBar(JScrollBar.VERTICAL);
        sspanel.add(scroller,BorderLayout.EAST);
        sspanel.setScroller(scroller);
        //an AdjustmentListener must be added to give the scroll bar the correct behavior
        //when is moved.
        scroller.addAdjustmentListener(new AdjustmentListener(){
                public void adjustmentValueChanged(AdjustmentEvent event){
                    JScrollBar scrollbar = (JScrollBar)event.getSource();
                    // the position of the scroll bar determines what data
                    // should be shown.
                    sspanel.setTopIndexByPixelValue(scrollbar.getValue());
                    //the spanel must be updated everytime the scroll bar moves
                    sspanel.repaint();
                }
            });
        // a scroll bar without mouse wheel support is not good.
        sspanel.addMouseWheelListener(new MouseWheelListener(){
                public void mouseWheelMoved(MouseWheelEvent event){
                    // find out which way is the mouse wheel being rotated   
                    if(event.getWheelRotation() > 0){
                        //we set the Value twice just to speed the scrolling a bit
                        scroller.setValue(sspanel.incrementTopIndex());
                        scroller.setValue(sspanel.incrementTopIndex());
                    }
                    else{
                        //we set the Value twice just to speed the scrolling a bit
                        scroller.setValue(sspanel.decrementTopIndex());
                        scroller.setValue(sspanel.decrementTopIndex());
                    }
                    sspanel.repaint();
                }
            });
        // change the backgourn of the sspanel to make it more readable
        sspanel.setBackground(Color.white);
        
        // the following constrains force the sspanel to be to the right of the testPanel
        gbc.anchor = GridBagConstraints.CENTER;
        gbc.gridwidth = GridBagConstraints.REMAINDER;
        gbc.fill = GridBagConstraints.BOTH;
        gbc.insets = new Insets(15,15,0,15);
        add(sspanel, gbc);        
        
        // finally we add rDPanel to the daqPanel
        rDPanel = new ResetDebugPanel();
        // the constrains force it to be on the bottom and to take the reaminding space
        gbc.anchor = GridBagConstraints.WEST;
        gbc.gridwidth = GridBagConstraints.REMAINDER;
        gbc.gridheight = GridBagConstraints.REMAINDER;
        gbc.fill = GridBagConstraints.BOTH;
        add(rDPanel,gbc);

        // if the reset bottom is pressed then the sspanel gets reset
        rDPanel.reset.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent event){
                    sspanel.reset();
                    repaint();
                }
            });

        // if focus is gained, usually with tab, then is set as default
        rDPanel.reset.addFocusListener(new FocusListener(){
                public void focusGained(FocusEvent event){
                    rootPane.setDefaultButton(rDPanel.reset);
                }
                // method is abstract so it must be overwritten
                public void focusLost(FocusEvent event){}
            });



        // if the resetAll button is pressed all the fields of the daqPanel
        // are set to default values
        rDPanel.resetAll.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent event){
                    connectPanel.commandPort.setText("55055");
                    connectPanel.daqServer.setText("localhost");
                    testPanel.commandText.setText("");
                    testPanel.resultText.setText("");
                    testPanel.suiteRuns.setText("1");
                    testPanel.readDataNum.setText("1");
                    sspanel.reset();
                    repaint();
                }
            });
        
        // if focus is gained, usually with tab, then is set as default
        rDPanel.resetAll.addFocusListener(new FocusListener(){
                public void focusGained(FocusEvent event){
                    rootPane.setDefaultButton(rDPanel.resetAll);
                }
                // method is abstract so it must be overwritten
                public void focusLost(FocusEvent event){}
            });


        // the debugInfo allows the user to log debugging information or not
        // mainly for performance
        rDPanel.debugInfo.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent event){
                    if(rDPanel.debugInfo.isSelected()){
                        DaqDriverTest.debug = true;
                    }
                    else{
                        DaqDriverTest.debug = false;
                    }
                }
            });

        // even if the debugging information is being log only if the
        // showDebugInf is selected it will be displayed
        rDPanel.showDebugInf.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent event){
                    if(rDPanel.showDebugInf.isSelected()){
                        sspanel.showDebugging();
                    }
                    else{
                        sspanel.hideDebugging();
                    }
                    sspanel.repaint();
                }
            });

        // activate rollover in buttons 
        connectPanel.connection.setRolloverEnabled(true);
        connectPanel.disconnect.setRolloverEnabled(true);
        testPanel.commandTestB.setRolloverEnabled(true);
        testPanel.readDataB.setRolloverEnabled(true);
        testPanel.testSuiteB.setRolloverEnabled(true);
        testPanel.readDataB.setRolloverEnabled(true);

        // adding listeners so if Enter is pressed on TextFields them simulated clicking
        // a button
        connectPanel.commandPort.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent event){
                    connectPanel.connection.doClick();
                }
            });
        connectPanel.daqServer.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent event){
                    connectPanel.connection.doClick();
                }
            });

        testPanel.commandText.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent event){
                    testPanel.commandTestB.doClick();
                }
            });

        testPanel.resultText.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent event){
                    testPanel.commandTestB.doClick();
                }
            });

        // adding the require listeners to connectPanel.connection button
        // if click it trys to connect and has error handling
        connectPanel.connection.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent event){
                    if(isConnected){
                        daqTests.disconnect();
                        daqTests = null;
                    }
                    int commandPort = 0;
                    try{
                        commandPort = Integer.parseInt(connectPanel.commandPort.getText().trim());
                        if (commandPort < 0){
                            throw new NumberFormatException();
                        }
                    }
                    catch(NumberFormatException exception){
                        JOptionPane.showMessageDialog(null, "Invalid port number: " 
                                                      + connectPanel.commandPort.getText().trim() +
                                                      "\nat 'Command Port'",
                                                      "Invalid Number", JOptionPane.INFORMATION_MESSAGE);
                        return;
                    }
                    // set command ports
                    DaqTests.setPorts(commandPort);
                    // attempts to connect
                    daqTests = new DaqTests(connectPanel.daqServer.getText());
                    // if connection succeted then we update the status
                    updateConnectionStatus();
                }
            });

        // if isRollover() then its set as the default button
        connectPanel.connection.addChangeListener(new ChangeListener(){
                public void stateChanged(ChangeEvent event){
                    ButtonModel model = connectPanel.connection.getModel();
                    if(model.isRollover()){
                        rootPane.setDefaultButton(connectPanel.connection);
                    }
                }
            });
        
        // if focus is gained, usually with tab, then is set as default
        connectPanel.connection.addFocusListener(new FocusListener(){
                public void focusGained(FocusEvent event){
                    rootPane.setDefaultButton(connectPanel.connection);
                }
                // method is abstract so it must be overwritten
                public void focusLost(FocusEvent event){}
            });
        

        //adding the require listeners to connectPanel.disconnect button
        connectPanel.disconnect.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent event){
                    if(daqTests != null){
                        daqTests.disconnect();
                        daqTests = null;
                    }
                    updateConnectionStatus();
                }
            });

        // if isRollover() then its set as the default button
        connectPanel.disconnect.addChangeListener(new ChangeListener(){
                public void stateChanged(ChangeEvent event){
                    ButtonModel model = connectPanel.disconnect.getModel();
                    if(model.isRollover()){
                        rootPane.setDefaultButton(connectPanel.disconnect);
                    }
                }
            });

        // if focus is gained, usually with tab, then is set as default
        connectPanel.disconnect.addFocusListener(new FocusListener(){
                public void focusGained(FocusEvent event){
                    rootPane.setDefaultButton(connectPanel.disconnect);
                }
                public void focusLost(FocusEvent event){}
            });
        
        // adding the require listeners to testPanel.readDataB
        testPanel.readDataB.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent event){
                    if(!isConnected){
                        JOptionPane.showMessageDialog(null, "must stablish connection",
                                                      "Error", JOptionPane.ERROR_MESSAGE);
                        return;
                    }
                    if(openPorts.size() == 0){
                        JOptionPane.showMessageDialog(null, "A port must be open",
                                                      "Error", JOptionPane.ERROR_MESSAGE);
                        return;
                    }
                    String str = testPanel.readDataNum.getText();
                    int runs = 0;
                    // mare sure number or runs is acceptable
                    try{
                        runs = Integer.parseInt(str.trim());
                        if (runs < 0){
                            throw new NumberFormatException();
                        }
                    }
                    catch(NumberFormatException e1){
                        JOptionPane.showMessageDialog(null, "Invalid run number: " 
                                                      + str.trim() +
                                                      "\nat 'Times to read Data'",
                                                      "Invalid Number", 
                                                      JOptionPane.ERROR_MESSAGE);
                        return;
                    }



                    // java compiler complains ir runs is used as not being a final variable
                    // because is access by a subclass
                    final int runsb = runs;
                    // dialog that gives the option to stop testing
                    final JDialog dialog = new JDialog(new JFrame(), "Reading Data", true);
                    final StopThread test = new StopThread(){
                            public void run(){
                                StringTokenizer dataTokens = null;
                                String str2 = "";
                                try{
                                    for(int j = 0;j < runsb ; j++){
                                            // check if the current tread was stopped
                                        if(((StopThread)Thread.currentThread()).isStopped()){
                                            return;
                                        }
                                        str2 = daqTests.readingData();
                                        dataTokens = new StringTokenizer(str2);
                                        while(dataTokens.hasMoreElements()){
                                            // check if the current tread was stopped
                                            if(((StopThread)Thread.currentThread()).isStopped()){
                                                return;
                                            }
                                            str2 = "";
                                            while(true){
                                            // check if the current tread was stopped
                                                if(((StopThread)Thread.currentThread()).isStopped()){
                                                    return;
                                                }
                                                if(!dataTokens.hasMoreElements()){
                                                    break;
                                                }
                                                str2 = str2 + dataTokens.nextToken() + "     ";
                                                if(str2.length() >= 60){
                                                    break;
                                                }
                                            }
                                            if(str2 != ""){
                                                sspanel.logString(str2);
                                            }
                                        }
                                        
                                        // go to line them up.
                                        repaint();
                                    }
                                }catch(TestSuiteException exception){
                                    dialog.dispose();
                                    exception.run();
                                    updateConnectionStatus();
                                    return;
                                }
                                updateConnectionStatus();
                                dialog.dispose();
                            }
                        };
                    
                    Container dialogContentPane = dialog.getContentPane();
                    JButton cancel = new JButton("Stop Reading Data");
                    dialogContentPane.setLayout(new FlowLayout());
                    dialogContentPane.add(cancel);
                    test.start();
                    dialog.pack();
                    dialog.setLocationRelativeTo(curDaqPanel);
                    cancel.addActionListener(new ActionListener(){
                            public void actionPerformed(ActionEvent event){
                                test.stopThread();
                                test.interrupt();
                                try{
                                    Thread.sleep(500);
                                }
                                catch(InterruptedException e){
                                    Thread.currentThread().yield();
                                }
                                if(test.isAlive()){
                                    daqTests.disconnect();
                                    updateConnectionStatus();
                                }
                                dialog.dispose();
                            }
                        });
                    dialog.show();
                    
                }
            });
        
        
        // if isRollover() then it becomes default
        testPanel.readDataB.addChangeListener(new ChangeListener(){
                public void stateChanged(ChangeEvent event){
                    ButtonModel model = testPanel.readDataB.getModel();
                    if(model.isRollover()){
                        rootPane.setDefaultButton(testPanel.readDataB);
                    }
                }
            });

        // if focus is gained, usually with tab, then is set as default        
        testPanel.readDataB.addFocusListener(new FocusListener(){
                public void focusGained(FocusEvent event){
                    rootPane.setDefaultButton(testPanel.readDataB);
                }
                public void focusLost(FocusEvent event){}
            });




        // adding the require listeners to testPanel.commandTestB
        testPanel.commandTestB.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent event){
                    String strCommand = testPanel.commandText.getText().trim();
                    String strResult = testPanel.resultText.getText().trim();
                    String data[] = null;
                    if(strCommand != "" && strCommand.startsWith("open-port")){
                        // replace blanks with nothing to store them in table
                        String key = strCommand.replaceAll(" ", "");
                        if(!openPorts.contains(key)){
                            openPorts.put(key,key);
                        }
                    }
                    if(strCommand != "" && strCommand.startsWith("close-port")){
                        String key = strCommand.replaceAll(" ", "").replaceAll("close", "open");
                        if(openPorts.contains(key)){
                            openPorts.remove(key);
                        }
                    }
                    // if not connected nothing to do
                    if(!isConnected){
                        JOptionPane.showMessageDialog(null, "must stablish connection",
                                                      "Error", JOptionPane.ERROR_MESSAGE);
                        return;
                    }
                    // if command is empty nothing to do
                    else if(strCommand.length() == 0){
                        JOptionPane.showMessageDialog(null, "Command cannot be 'null' or blank string",
                                                      "Error", JOptionPane.ERROR_MESSAGE);
                        return;
                    }
                    else if(strResult.length() > 0){
                        TestResult result = null;
                        try{
                            result = daqTests.testCommand(strCommand + "\n", strResult);
                        }
                        catch(TestSuiteException e1){
                            e1.run();
                            // the connection might be lost
                            updateConnectionStatus();
                            result = new TestResult();
                            result.pass = false;
                            result.different = "";
                            updateConnectionStatus();
                        }
                        if(result.pass){
                            data = new String[1];
                            data[0] = "Command being tested: " + strCommand + "         PASS";
                        }
                        else{
                            String str = "Expected result: " + strResult + 
                                " DAQ return: " + result.different;
                            data = new String[str.length() / SSPanel.MAXLINE + 2];
                            data[0] = "Command being tested: " + strCommand + "         FAIL";
                            for(int i = 0; i < data.length - 1; i++){
                                if(i == 0){
                                    data[i + 1] = str.substring(i * SSPanel.MAXLINE, 
                                                                Math.min(SSPanel.MAXLINE*(i + 1),str.length()));
                                }
                                else{
                                    data[i + 1] = "     " + 
                                        str.substring(i * SSPanel.MAXLINE, Math.min(SSPanel.MAXLINE*(i + 1),str.length()));
                                }
                            }   
                        }
                        
                    }
                    
                    // if there is nothing to compare the result with
                    else{
                        String str = "";
                        try{
                            str = daqTests.testCommand(strCommand + "\n");
                        }
                        catch(TestSuiteException e2){
                            e2.run();
                            updateConnectionStatus();
                        }
                        data = new String[str.length() / SSPanel.MAXLINE + 2];
                        for(int i = 0; i < data.length - 1; i++){
                            if(i == 0){
                                data[i + 1] = str.substring(i * SSPanel.MAXLINE, 
                                                            Math.min(SSPanel.MAXLINE*(i + 1),str.length()));
                            }
                            else{
                                data[i + 1] = "     " + 
                                    str.substring(i * SSPanel.MAXLINE, Math.min(SSPanel.MAXLINE*(i + 1),str.length()));
                            }
                        }
                        data[1] = "Result: " + data[1];
                        data[data.length - 1] = data[data.length - 1];
                        data[0] = "Command being tested: " + strCommand;
                    }
                    sspanel.logCommand(data);
                    sspanel.repaint();
                }
            });

        // if isRollover() then it becomes default
        testPanel.commandTestB.addChangeListener(new ChangeListener(){
                public void stateChanged(ChangeEvent event){
                    ButtonModel model = testPanel.commandTestB.getModel();
                    if(model.isRollover()){
                        rootPane.setDefaultButton(testPanel.commandTestB);
                    }
                }
            });

        // if focus is gained, usually with tab, then is set as default        
        testPanel.commandTestB.addFocusListener(new FocusListener(){
                public void focusGained(FocusEvent event){
                    rootPane.setDefaultButton(testPanel.commandTestB);
                }
                public void focusLost(FocusEvent event){}
            });


        //adding the require listeners to testPanel.testSuiteB button
        testPanel.testSuiteB.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent event){
                    // reste openPorts because after test suite is done all will be close
                    openPorts = new Hashtable();
                    // make sure is connected
                    if(!isConnected){
                        JOptionPane.showMessageDialog(null, "must stablish connection",
                                                      "Error", JOptionPane.ERROR_MESSAGE);
                        return;
                    }
                    sspanel.reset();
                    repaint();
                    
                    String str = testPanel.suiteRuns.getText();
                    int runs = 0;
                    // mare sure number or runs is accpetable
                    try{
                        runs = Integer.parseInt(str.trim());
                        if (runs < 0){
                            throw new NumberFormatException();
                        }
                    }
                    catch(NumberFormatException exception){
                        JOptionPane.showMessageDialog(null, "Invalid run number: " 
                                                      + str.trim() +
                                                      "\nat 'Test Runs'",
                                                      "Invalid Number", 
                                                      JOptionPane.ERROR_MESSAGE);
                        return;
                    }
                    // java compiler complains ir runs is used as not being a final variable
                    // because is access by a subclass
                    final int runsb = runs;
                    // dialog that gives the option to stop testing
                    final JDialog dialog = new JDialog(new JFrame(), "Testing Progress", true);
                    final JProgressBar progressBar = new JProgressBar();
                    progressBar.setStringPainted(true);

                    final StopThread test = new StopThread(){
                            public void run(){
                                int counter = 0;
                                try{
                                    for(int j = 0;j < runsb ; j++){
                                        if(((StopThread)Thread.currentThread()).isStopped()){
                                            daqTests.flushBuffers(curDaqPanel, sspanel, true);
                                            return;
                                        }
                                        if(!daqTests.testSuite(curDaqPanel, sspanel, progressBar, runsb)){
                                            counter++;
                                        }
                                    }
                                    if(((StopThread)Thread.currentThread()).isStopped()){
                                        daqTests.flushBuffers(curDaqPanel, sspanel, true);
                                        return;
                                    }
                                    if(runsb > 1){
                                        if(counter > 0){
                                            sspanel.logString("Out of " + runsb + " Runs " + 
                                                              counter + " FAIL");
                                        }
                                        else{
                                            sspanel.logString("All " + runsb + "Runs PASS");
                                        }
                                    }
                                }catch(TestSuiteException exception){
                                    dialog.dispose();
                                    exception.run();
                                    updateConnectionStatus();
                                    return;
                                }
                                updateConnectionStatus();
                                dialog.dispose();
                            }
                        };
                    
                    Container dialogContentPane = dialog.getContentPane();
                    JButton cancel = new JButton("Stop testing");
                    dialogContentPane.setLayout(new FlowLayout());
                    dialogContentPane.add(progressBar);
                    dialogContentPane.add(cancel);
                    test.start();
                    dialog.pack();
                    dialog.setLocationRelativeTo(curDaqPanel);
                    cancel.addActionListener(new ActionListener(){
                            public void actionPerformed(ActionEvent event){
                                test.stopThread();
                                try{
                                    Thread.sleep(5000);
                                }
                                catch(InterruptedException e){
                                    Thread.currentThread().yield();
                                }
                                if(test.isAlive()){
                                    daqTests.disconnect();
                                    updateConnectionStatus();
                                }
                                dialog.dispose();
                            }
                        });
                    dialog.show();
                }
            });
                // if isRollover() then it becomes default
        testPanel.testSuiteB.addChangeListener(new ChangeListener(){
                public void stateChanged(ChangeEvent event){
                    ButtonModel model = testPanel.testSuiteB.getModel();
                    if(model.isRollover()){
                        rootPane.setDefaultButton(testPanel.testSuiteB);
                    }
                }
            });

        // if focus is gained, usually with tab, then is set as default        
        testPanel.testSuiteB.addFocusListener(new FocusListener(){
                public void focusGained(FocusEvent event){
                    rootPane.setDefaultButton(testPanel.testSuiteB);
                }
                public void focusLost(FocusEvent event){}
            });
        
        //setting connectPanel.connection to default right away
        //alouds to press enter and connect to localhost
        rootPane.setDefaultButton(connectPanel.connection);

    }

    public void updateConnectionStatus(){
        if(daqTests != null 
           && daqTests.validConnect){ 
            connectPanel.connectStat.setText("Connected");
            connectPanel.connectStat.setForeground(Color.green);
            isConnected = true;
        }
        else{
            connectPanel.connectStat.setText("offline      ");
            connectPanel.connectStat.setForeground(Color.red);
            isConnected = false;
            openPorts = new Hashtable();
        }
    }
}

---