package lawyer;

import java.awt.*;
import java.awt.event.*;

/**
 * <p>This Frame displays the data from the statistics section of a lesson.
 * It automatically displays itself when it is created.</p>
 *
 * @author  David Danks
 * @version 0.9; July 24, 1998
 * @see	LessonManager
 */
public class DataTableFrame extends Frame {

    /** @serial */
    public String[][] data;

    /** @serial */
    public String[] labels;

    /** @serial */
    public String[] attrib;

    /** @serial */
    private int xMax;

    /** @serial */
    private int yMax;

    /** @serial */
    private int height;

    /** @serial */
    private int drop;

    /** @serial */
    private int tableX;

    /** @serial */
    private int tableY;

    /** @serial */
    private int[] maxColWidth;

    /** @serial */
    private FontMetrics fm;

    private static final int MARGIN = 10;

/**
 * Constructor for the DataTableFrame.
 *
 * @param   dat	    A two-dimensional String array of the actual data.  The 
 *		    format is String[row][column].
 * @param   dataLabels	A one-dimensional String array of the row and column
 *			tags.  It is assumed that the first half of the 
 *			array will be column labels, and the second half will
 *			be row names, with <code>null</code> Strings in 
 *			between, if necessary.
 * @param   attrib  A one-dimensional String array of the reference for the
 *		    data, of the form String[line_of_text].
 * @param   font    The font to display the text in.
 */
    public DataTableFrame(String dat[][], String dataLabels[], String attrib[], 
	Font font) {
	super("Data Table");
	this.data = dat;
	this.labels = dataLabels;
	this.attrib = attrib;
	fm = this.getFontMetrics(font);
	
	// determine the size of the table
	height = fm.getHeight() + 10;
	drop = height - fm.getDescent();
	maxColWidth = new int[data[0].length+1];
	for (int i=0; i<(labels.length / 2); i++) {
	    if (labels[i] == null) break;
	    else {
		maxColWidth[0] = Math.max(maxColWidth[0],
		    fm.stringWidth(labels[i]) + 5); }
	}
	for (int i=0; i<maxColWidth.length-1; i++) {
	    maxColWidth[i+1] = 
		fm.stringWidth(labels[(labels.length / 2)+i])+5;
	    for (int j=0; j<data.length; j++) {
		maxColWidth[i+1] = Math.max(maxColWidth[i+1],
		    fm.stringWidth(data[j][i])+5); }
	}
	xMax = 0;
	for (int i=0; i<maxColWidth.length; i++) { xMax += maxColWidth[i]; }
	yMax = height * (dat.length + 1);
	tableX = xMax; tableY = yMax;
	// now check/adjust the sizes for the attribution
	if (attrib.length > 0) { yMax += 10; }
	for (int i=0; i<attrib.length; i++) {
	    if (attrib[i] == null) break;
	    yMax += height;
	    xMax = Math.max(xMax, fm.stringWidth(attrib[i])); }
	this.setSize(xMax+2*MARGIN, yMax+2*MARGIN);
	this.addWindowListener(new WindowAdapter() {
	    public void windowClosing(WindowEvent w) {
		DataTableFrame.this.dispose(); }
	    });
	this.pack();
	this.show();
    }

/**
 * @return  A Dimension object encoding the size it wants to be.
 */
    public Dimension getPreferredSize() {
	return new Dimension(this.getSize()); }
/**
 * @return  A Dimension object encoding the size it must be.
 */ 
    public Dimension getMinimumSize() {
	return new Dimension(this.getSize()); }
    
/**
 * Draws all of the lines and text to create the table and reference.
 */
    public void paint(Graphics g) {
	g.translate(MARGIN, MARGIN);
	// draw the horizontal lines and row names
	for (int i=0; i<data.length+1; i++) {  
	    g.drawLine(maxColWidth[0], height*(i+1), tableX, height*(i+1)); 
	    if (i != data.length) {
		g.drawString(labels[i], 0, height*(i+1) + drop); }
	    }
	// draw everything else
	for (int i=0; i<data[0].length+1; i++) {	
	    int inset = 0;
	    for (int j=0; j<=i; j++) { inset += maxColWidth[j]; }
	    g.drawLine(inset, height, inset, tableY); 
	    if (i != data[0].length) {
		int x = (maxColWidth[i+1] -
		    fm.stringWidth(labels[labels.length/2+i])) / 2;
		g.drawString(labels[(labels.length/2)+i], inset+x, drop);
		for (int j=0; j<data.length; j++) {
		    x = (maxColWidth[i+1] - 
			fm.stringWidth(data[j][i])) / 2;
		    g.drawString(data[j][i], inset+x, height*(j+1) + drop); }
	}   }
	int yOffset = height*(data.length+1)+drop+10;
	for (int i=0; i<attrib.length; i++) {
	    if (attrib[i] == null) break;
	    g.drawString(attrib[i], 0, yOffset);
	    yOffset += height; }
    }
}