package lawyer;

import java.awt.*;
import java.util.*;

/**
 * <p>This class displays as much of its text on each page as possible.
 * Note: It does the text-wrapping and page-fitting at the beginning, so
 * subsequent resizings will not have an effect.  This dynamic "re-fitting"
 * is something I would like to add to the code.</p>
 *
 * @author  David Danks
 * @version 0.9; July 24, 1998
 * @see	LessonManager
 */
public class TextCanvas extends Canvas {

    /** @serial */
    protected String[][] text;

    /** @serial */
    protected int xMax;

    /** @serial */
    protected int yMax;

    /** @serial */
    protected int dialog = 0;

    /** @serial */
    protected Font boldFont;

    /** @serial */
    protected Font plainFont;

    /** @serial */
    protected int INSET = 5;
    
/**
 * Creates the TextCanvas, and does all of the text-wrapping and page-fitting.
 *
 * @param   text    A two-dimensional String array of the text to be displayed,
 *		    in the format String[individual's_speech][line_of_speech]
 * @param   f	    The font in which to display the text
 * @height  width   The maximum width available for the TextCanvas
 * @height  height  The maximum height available for the TextCanvas
 */
    public TextCanvas(String[][] text, Font f, int width, int height) {
	this.setFont(f);
	this.text = setText(text, width, height);
	plainFont = getFont();
	boldFont = new Font(getFont().getName(), 
	    Font.BOLD, getFont().getSize());
	xMax = getWidestString();
	yMax = getTallestSection();
    }
    
/**
 * Draws all of the text on the Canvas, putting the names in bold.
 */
    public void paint(Graphics g) {
	g.translate(INSET, 0);
	g.setFont(boldFont);
	for (int i=0; i<text[dialog].length; i++) {
	    g.drawString(text[dialog][i], 0, 
		getFontMetrics(getFont()).getHeight()*i+
		    getFontMetrics(getFont()).getAscent());
	    if (g.getFont().isBold()) { g.setFont(plainFont); }
	    if (text[dialog][i].equals("")) { g.setFont(boldFont); }
	}
    }
    
/**
 * This method does two things.  First, it separates off the speaker's name, 
 * and then text-wraps, so that each line is as long as possible (given maxW).
 * Then, it puts the speeches together so that as many complete speeches as 
 * possible are displayed at once.
 *
 * @param   text    A two-dimensional String array of the text to be displayed
 * @param   maxW    The maximum width of the TextCanvas
 * @param   maxH    The maximum height of the TextCanvas
 */
    private String[][] setText(String[][] text, int maxW, int maxH) {
	FontMetrics fm = getFontMetrics(getFont());
	maxW -= INSET;
	// first, we do the text-wrapping and separate out the speaker
	String[][] wrap = new String[text.length][100];
	for (int i=0; i<text.length; i++) {
	    int num = 0;
	    for (int j=0; j<text[i].length; j++) {
		StringTokenizer st = new StringTokenizer(text[i][j]);
		if (j == 0) { 
		    wrap[i][num] = st.nextToken(); 
		    num++; 
		    wrap[i][num] = st.nextToken(); }
		while (st.hasMoreTokens()) {
		    String next = st.nextToken();
		    if (fm.stringWidth(wrap[i][num]+" "+next) < maxW) {
			wrap[i][num] += " "+next; }
		    else { num++; wrap[i][num] = next; }
		}
	    }
	    wrap[i][num+1] = "";
	}
	// now we put as many speeches as possible on each screen.
	String[][] temp = new String[wrap.length][100];
	int j; for (j=0; j<wrap[0].length; j++) {
	    if (wrap[0][j] == null) break; }
	System.arraycopy(wrap[0], 0, temp[0], 0, j);
	int screen = 0; int dial = j; int currH = fm.getHeight()*j; 
	for (int i=1; i<wrap.length; i++) {
	    for (j=0; j<wrap[i].length; j++) {
		if (wrap[i][j] == null) break; }
	    if (currH + j*fm.getHeight() < maxH) {
		System.arraycopy(wrap[i], 0, temp[screen], dial, j); 
		dial +=j; currH += j*fm.getHeight(); }
	    else {
		screen++; dial = j; currH = j*fm.getHeight();
		System.arraycopy(wrap[i], 0, temp[screen], 0, j); }
	}
	// now return a pared-down array
	String[][] ret = new String[screen+1][];
	for (int i=0; i<ret.length; i++) {
	    int k; for (k=0; k<temp[i].length; k++) {
		if (temp[i][k] == null) break; }
	    ret[i] = new String[k];
	    System.arraycopy(temp[i], 0, ret[i], 0, ret[i].length);
	}
	return ret;
    }
    
    public int getNumDialogs() { return text.length; }
    
/**
 * Sets the dialog number (essentially, the page number) to <code>dial</code>.
 * Requires a repaint() for the display to change.
 *
 * @param   dial    The dialog/page number to be made current
 */
    public void setDialogNum(int dial) { 
	// make sure it's a legitimate number before assigning it
	dial = (dial< 0) ? 0 : dial; 
	dialog = (dial > text.length-1) ? text.length-1 : dial;
    }
    
/**
 * @return  The width of the widest String
 */
    private int getWidestString() {
	int max = 0;
	for (int i=0; i<text.length; i++) {
	    for (int j=0; j<text[i].length; j++) {
		max = Math.max(max, 
		    getFontMetrics(getFont()).stringWidth(text[i][j]));
	}   }
	return max;
    }

/**
 * @return  The height (in pixels) of the tallest section/page.
 */    
    private int getTallestSection() {
	int max = 0;
	for (int i=0; i<text.length; i++) {
	    max = Math.max(max, text[i].length); }
	max *= getFontMetrics(getFont()).getHeight();
	return max;
    }
    
/**
 * @return A Dimension object of the size it wants to be.
 */
    public Dimension getPreferredSize() { 
	return new Dimension(xMax+INSET+1, yMax+1); }
/**
 * @return A Dimension object of the size it has to be.
 */
    public Dimension getMinimumSize() {
	return new Dimension(xMax+INSET+1, yMax+1); }
}