SSPanel.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 SSPanel extends JPanel{
    private int topIndex = 0;
    
    private int fontHeight;
    
    public static boolean showDebug = false;

    private JScrollBar scroller;

    private Vector data = new Vector();

    private Vector debug = new Vector();
    
    private Vector noDebug = data;
    
    public static final int MAXLINE = 65;

    private Hashtable pairs = new Hashtable();

    public void setScroller(JScrollBar scroll){
        scroller = scroll;
    }
    
    public void paintComponent(Graphics graphics){
        Color color = graphics.getColor();
        String str;
        super.paintComponent(graphics);
        graphics.setColor(color);
        
        Dimension size = getSize();
        Insets insets = getInsets();
        int yaxis = insets.top + getUnitHeight();
        // for loop that draws strings till no more fit in the panel or till
        // there is no more data
        for(int i = topIndex; i < data.size(); ++i, yaxis += fontHeight) {
            str = (String)data.elementAt(i);
            // if there is no PASS or FAIL just draw the string
            if(str.length() < 7){
                graphics.drawString((String)data.elementAt(i), 0, yaxis);
                continue;
            }
            // If the string PASS is encounter at the end of an entry
            // in the data its painted green
            if(str.substring(str.length() - 4, str.length()).equals("PASS")){
                graphics.drawString(str.substring(0,str.length() - 4), 0, yaxis);
                graphics.setColor(Color.green);
                graphics.drawString("PASS", (size.width * 3) / 4, yaxis);
                graphics.setColor(color);
            }
            // If the string FAIL is encounter at the end is painted red 
            else if(str.substring(str.length() - 4, str.length()).equals("FAIL")){
                graphics.drawString(str.substring(0,str.length() - 4), 0, yaxis);
                graphics.setColor(Color.red);
                graphics.drawString("FAIL", (size.width * 3) / 4, yaxis);
                graphics.setColor(color);
            }
            else{
                graphics.drawString((String)data.elementAt(i), 0, yaxis);
            }
            if(yaxis + fontHeight> size.height - insets.bottom){
                break;
            }
        }
        
    }
    
    public void setTopIndexByPixelValue(int pixelValue){
        topIndex = pixelValue/ fontHeight;
    }

    public int incrementTopIndex(){
        Dimension size = getSize();
        if(topIndex >= data.size() - size.height / fontHeight){
            return (topIndex + 1) * fontHeight;
        }
        topIndex++;
        return topIndex * fontHeight;
    }
    
    public int decrementTopIndex(){
        if(topIndex <= 0){
            return 0;
        }
        topIndex--;
        return topIndex * fontHeight;
    }

    public Dimension getPreferredSize(){
        Dimension dim = new Dimension();
        Graphics graphics = getGraphics();
        try {
            FontMetrics fontmetrics = graphics.getFontMetrics();
            fontHeight = fontmetrics.getHeight();
            if(data.size() > 0){
                dim.width = fontmetrics.stringWidth((String)data.elementAt(data.size()-1));
            }
            else{
                dim.width = 0;
            }
            dim.height = fontmetrics.getHeight() * (data.size() + 1);
        }
        finally {
            graphics.dispose();
        }
        return dim;
    }

    public int getUnitHeight(){
        return fontHeight;
    }

    public void reset(){
        data = new Vector();
        debug = new Vector();
        noDebug = data;
        if(showDebug){
            data = debug;
        }
        pairs = new Hashtable();
    }
    
    public void logCommand(String[] data){
        for(int i = 0; i < data.length; i++){
            this.noDebug.add(data[i]);
            if(DaqDriverTest.debug){
                debug.add(data[i]);
            }
        }
        // Everytime something is added to the data Vectors the size of the
        // scroller needs to be recalculated.
        Dimension pref = getPreferredSize();
        Dimension size = getSize();        
        topIndex = this.noDebug.size() - (getSize().height / fontHeight);
        if(topIndex < 0){
            topIndex = 0;
        }

        int extent = size.height, max = pref.height;
        int value = Math.max(0, Math.min(scroller.getValue(), max - extent));
        scroller.setVisible(extent < max);
        scroller.setUnitIncrement(getUnitHeight());
        scroller.setBlockIncrement(extent - scroller.getUnitIncrement());
        scroller.setValues(value, extent, 0, max);
        scroller.setValue(max);   
    }
    
    public int logString(String stri){
        String str = stri.replaceAll("\t", "     ");
        if(str.length() <= MAXLINE){
            noDebug.add(str);
            if(DaqDriverTest.debug){
                debug.add(str);
            }
        }
        else{
            for(int i = 0; i < str.length() / MAXLINE + 1; i++){
                if(i == 0){
                    noDebug.add(str.substring(i * SSPanel.MAXLINE, 
                                              Math.min(SSPanel.MAXLINE*(i + 1),str.length())));
                    if(DaqDriverTest.debug){
                        debug.add(str.substring(i * SSPanel.MAXLINE, 
                                                Math.min(SSPanel.MAXLINE*(i + 1),str.length())));
                    }       
                }
                else{
                    noDebug.add("     " + 
                                str.substring(i * SSPanel.MAXLINE, 
                                              Math.min(SSPanel.MAXLINE*(i + 1),str.length())));
                    if(DaqDriverTest.debug){
                        debug.add("     " + 
                                  str.substring(i * SSPanel.MAXLINE, 
                                                Math.min(SSPanel.MAXLINE*(i + 1),str.length())));
                    }       
                }
            }            
        }
       
        // Everytime some data is log the scroller needs to be resized
        Dimension pref = getPreferredSize();
        Dimension size = getSize();        
        topIndex = this.data.size() - (getSize().height / fontHeight);
        if(topIndex < 0){
            topIndex = 0;
        }
        int extent = size.height, max = pref.height;
        int value = Math.max(0, Math.min(scroller.getValue(), max - extent));
        scroller.setVisible(extent < max);
        scroller.setUnitIncrement(getUnitHeight());
        scroller.setBlockIncrement(extent - scroller.getUnitIncrement());
        scroller.setValues(value, extent, 0, max);
        scroller.setValue(max);   
        if(DaqDriverTest.debug){
            pairs.put(new Integer(data.size() - 1), new Integer(debug.size() - 1));
        }
        return noDebug.size() - 1;
    }
    public int logDebugString(String str){
        if(str.length() <= MAXLINE){
            debug.add(str);
        }
        else{
            for(int i = 0; i < str.length() / MAXLINE + 1; i++){
                if(i == 0){
                    debug.add(str.substring(i * SSPanel.MAXLINE, 
                                            Math.min(SSPanel.MAXLINE*(i + 1),str.length())));
                    
                }
                else{
                    debug.add("     " + str.substring(i * SSPanel.MAXLINE, 
                                                      Math.min(SSPanel.MAXLINE*(i + 1),str.length())));
                }
            }            
        }
        // if the debugging information is being shown scroller needs
        // to be resize otherwise it does not.
        if(showDebug){
            Dimension pref = getPreferredSize();
            Dimension size = getSize();        
            topIndex = this.data.size() - (getSize().height / fontHeight);
            if(topIndex < 0){
                topIndex = 0;
            }
            int extent = size.height, max = pref.height;
            int value = Math.max(0, Math.min(scroller.getValue(), max - extent));
            scroller.setVisible(extent < max);
            scroller.setUnitIncrement(getUnitHeight());
            scroller.setBlockIncrement(extent - scroller.getUnitIncrement());
            scroller.setValues(value, extent, 0, max);

            scroller.setValue(max);   
        } 
        return debug.size() - 1;
    }
    
    public void replaceLog(String str, int index){
        noDebug.setElementAt(str, index);
        if(DaqDriverTest.debug){
            if(pairs.containsKey(new Integer(index))){
                debug.setElementAt(str, ((Integer)pairs.get(new Integer(index))).intValue());
            }
        }
    }
    
    public void showDebugging(){
        data = debug;
        showDebug = true;
        Dimension pref = getPreferredSize();
        Dimension size = getSize();        
        topIndex = this.data.size() - (getSize().height / fontHeight);
        if(topIndex < 0){
            topIndex = 0;
        }
        int extent = size.height, max = pref.height;
        int value = Math.max(0, Math.min(scroller.getValue(), max - extent));
        scroller.setVisible(extent < max);
        scroller.setUnitIncrement(getUnitHeight());
        scroller.setBlockIncrement(extent - scroller.getUnitIncrement());
        scroller.setValues(value, extent, 0, max);
        scroller.setValue(max);   
    }
    
    public void hideDebugging(){
        data = noDebug;
        showDebug = false;
        Dimension pref = getPreferredSize();
        Dimension size = getSize();        
        topIndex = this.data.size() - (getSize().height / fontHeight);
        if(topIndex < 0){
            topIndex = 0;
        }
        int extent = size.height, max = pref.height;
        int value = Math.max(0, Math.min(scroller.getValue(), max - extent));
        scroller.setVisible(extent < max);
        scroller.setUnitIncrement(getUnitHeight());
        scroller.setBlockIncrement(extent - scroller.getUnitIncrement());
        scroller.setValues(value, extent, 0, max);
        scroller.setValue(max);   
    }

}

---