/**
 * Listor class is vaguely like a table object. But it is simpler,
 * so it is both easier to understand, and easier to work with.
 * It allows you to lay out a basic "table" of data, and also allows
 * the USER to resize the rows as they desire.
 *
 * Rather than being 'cell' oriented, Listor is row oriented.
 * For example, you can highlight a row, but not a specific field of
 * a row. This simplifies things greatly.
 *
 * There are a few hard-codes in here, but not too many.
 *
 * General use: Create a new instance of Listor, which is a subclass
 * of a regular AWT Panel.
 * You must define the number of columns you want, now and forever.
 * You also should define a total width currently.
 * 
 * From this point, you will want to do one or more of three operations;
 *
 *   Define column names, through Listor.setColName()
 *   Define initial column widths, through Listor.setColName()
 *   Add data rows, through Listor.addValues()
 *
 * Note that there is no "changeValues()" call; it is unneccessary,
 * since the values are only referenced, not copied.
 */

/* COPYRIGHT: Philip Brown, 2003
 * You may use this code however you like, as long as
 * you leave this copyright notice section unchanged, and
 * do not hold Philip Brown liable for any issues, bugs, damages, etc.
 * No warantee, assumed, or implied, is given with this software, etc. etc.
 * 
 * If you would like different license terms, talk to me
 *
 *  http://www.bolthole.com/java/
 *
 * END OF COPYRIGHT NOTICE
 */


/* Listor.java 1.16 */

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

/**
 * Just a subcomponent class for the Listor class below.
 * a DataPane can be a read-only dumb display unit, OR a "master"
 * unit, that allows for column width resizes.
 */
class DataPane extends Canvas implements java.awt.event.MouseMotionListener,
	java.awt.event.MouseListener
{
	Dimension mysize;
	
	boolean master, havecursor, highlighted;
	int havecolnum;   // joined to "havecursor". user has "grabbed" a col
	//java.awt.event.ActionListener parent;
	Listor parent;
	int widths[];
	String values[];
	Color bgcolor, fgcolor;

	/** pass in an array of column widths, and an array of
	 * string values for each column
	 * You also need a totalwidth estimation, although it
	 * is mostly unneccesary these days.
	 */
	public DataPane(int w[], String v[], int totalwidth){
		mysize=new Dimension();
		mysize.height=25; /* nasty hack, sigh */
		mysize.width=totalwidth;
		master=false;
		havecursor=false;
		havecolnum=0;

		widths=w;
		values=v;

		setSize(totalwidth, mysize.height);

		fgcolor=Color.black;
		bgcolor=Color.white;
		setBackground(bgcolor);

	}

	public void setBackground(Color col){
		highlighted=false;
		super.setBackground(col);
		bgcolor=col;
	}

	/* Modeled on the "standard" addMouseListener.
	 * But note that we can only have ONE registered listener
	 * Note also, that we only send a SUBSET of mouse events back
	 * to the parent
	 *
	 * This says that the 'parent' wants to know when we get clicked on.
	 * We will send the mouseReleased event back to the
	 * parent, so it can know which button was used, etc.
	 * Do not call this for the "master" DataPane
	 */
	public void addMouseListener(Listor Parent)
	{
		if(parent==null){
			addMouseListener(this);
		}
		parent=Parent;
	}

	public Dimension getPreferredSize(){
		return mysize;
	}
	public Dimension getMinimumSize(){
		System.out.println("datapane: gerMin");
		return getPreferredSize();
	}

	void setValues(String v[]){
		values=v;
	}

	/* return X coordinate of 'start' of a column.
	 * Gives left-most X coordinate of a column.
	 */
	int getColStart(int endcol){
		int xpos=0;
		int col=0;

		if(endcol<0){
			return 0;
		}
		if(endcol>=widths.length){
			endcol=widths.length-1;
		}
		
		while(col<endcol){
			xpos+=widths[col++];
		}
		return xpos;
	}
	/* Similar to getColStart. However, this returns the
	 * X coord of the RIGHT side of a column.
	 * Note that ColStart + columnwidth exactly equals ColEnd
	 */
	int getColEnd(int Col){
		int xpos=0;
		int curcol=0;
		if(Col<0) Col=0;
		if(Col>=widths.length) Col=widths.length-1;

		while(curcol <=Col){
			xpos+=widths[curcol++];
		}
		return xpos;
	}

	public void setHighlighted(boolean isSet){
		if(isSet){
			super.setBackground(fgcolor);
			highlighted=true;
		} else {
			super.setBackground(bgcolor);
			highlighted=false;
		}

		/* unfortunately, this does a double bg-clear. oh well */
		repaint();

	}

	/* We paint the dividers at the 'right' of each column.
	*/
	public void paint(Graphics gc){
		int xpos=0;
		int colcount;
		if(highlighted)
			gc.setColor(bgcolor);
		else 
			gc.setColor(fgcolor);

		/* For speed purposes, circumvent getColStart/End.
		 * However, make sure to stay compatible with them!!
		 */
		for(colcount=0; colcount <widths.length; colcount++){
			int colwidth=widths[colcount];
			gc.setClip(xpos, 0, colwidth, mysize.height);
			if(values[colcount]!=null){
				gc.drawString(values[colcount],
			              xpos+3 , (mysize.height/2));
			}
			xpos=xpos + widths[colcount];
			gc.drawRect(xpos-3, 0 + 2, 2, mysize.height -4);
		}
		
		
	}


	/************************************************************/
	/** "master" means that we should allow the user to adjust the
	 * location of the dividers for this "row".
	 * We will also call our parent "Listor" object to let it know
	 * it should update all the other rows with their new column spacing.
	 */
	public void setMaster(Listor Parent){
		master=true;
		parent=Parent;
		addMouseMotionListener(this);
		addMouseListener(this);
		setBackground(Color.red);
	}

	public void mouseDragged(java.awt.event.MouseEvent evt){
		if(!havecursor){
			debug("mouseDragged: we dont have the cursor now");
			return;
		}

		int newx=evt.getX();
		int oldx=getColEnd(havecolnum);
		int startcol=getColStart(havecolnum);
		int minx=startcol+5;
		if(newx <minx) newx = minx;
		if(newx >=mysize.width) newx = mysize.width - 1;

		if(oldx==newx){
			//debug("mouseDragged: no size change");
			return;
		}
		
		//debug("MasterRow: dragging col "+havecolnum
		//	+ " to x coord "+newx);

		widths[havecolnum]=newx - startcol;

		parent.showUpdates();


		/*repaint();*/ /* This would redraw JUST the master row */
	}


	static public void debug(String msg){
		System.out.println(msg);
	}

	public void mousePressed(java.awt.event.MouseEvent evt){
		int colmatch=-1;
		if(havecursor){
			debug("mousePressed: HAVE cursor already??");
			// should never happen, but just in case...
			return;
		}

		/* We want to think of grabbing the separator to the "right"
		* of a column.
		*/
	 
		//debug("mousePressed: looking for match");
		for(int col=0;col<widths.length;col++){
			int tmpstart=getColEnd(col);
			if(Math.abs(evt.getX() - tmpstart) <4){
				colmatch=col;
				break;
			}
		}
		if(colmatch==-1){
			//debug("mousePressed: no match found");
			return;
		}


		havecolnum=colmatch;
		havecursor=true;
		setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

	}
	public void mouseReleased(java.awt.event.MouseEvent evt){
	
		if(!master){
			return;
		}
		if(!havecursor) return;
		setCursor(Cursor.getDefaultCursor());
		havecursor=false;
		havecolnum=0;

	}

	public void mouseMoved(java.awt.event.MouseEvent evt){
		/* dont care about this */
	}
	public void mouseClicked(java.awt.event.MouseEvent evt){
		/* dont care about this */
		if(master){
			return;
		}
		if(parent != null){
			parent.mouseClicked(evt);
		}
		return;

	}
	public void mouseEntered(java.awt.event.MouseEvent evt){
		/* dont care about this */
	}
	public void mouseExited(java.awt.event.MouseEvent evt){
		/* dont care about this */
	}

}


/**
 * This class is one big panel, that holds a "master row" at the
 * top, with resizable labels, and then a bunch of data rows below it.
 *
 */
public class Listor extends Panel
{
	int numcols, totalWidth;
	String colnames[];/* label for each colum */
	int colwidths[];  /* relative width of each column, including spacer*/
	Color databg;

	Dimension preferredsize;
	GridBagConstraints constraints;

	DataPane masterrow; /* this is NOT held in subpanes */

	Vector rows;   /* each entry is a DataPanel */
	int lastrowclicked=-1;

	/**
	 * @param numc number of columns you want every datarow to have
	 * @param totalwidth full pixel width of the entire Listor object
	 * 
	 */
	public Listor(int numc, int totalwidth){
		numcols=numc;
		colnames=new String[numcols];
		colwidths=new int[numcols];
		databg=Color.green; /* default background color */

		for(int cn=0; cn<numcols; cn++){
			colwidths[cn]=35; /* allow 5 pixels for spacer */
		}

		setLayout(new GridBagLayout());
		constraints=new GridBagConstraints();
		constraints.gridwidth=GridBagConstraints.REMAINDER;
		constraints.anchor=GridBagConstraints.NORTH;
		constraints.insets.top=1;


		preferredsize=new Dimension(totalwidth+10, 50);

		masterrow=new DataPane(colwidths, colnames, preferredsize.width-10);
		masterrow.setMaster(this);
		add(masterrow,constraints);

		rows=new Vector();

	}

	/** If you change the values in a pre-existing row,
	* by changing values in the String[] array you passed to
	* addValues(), then you will need to call this, to
	* show your updated values.
	*/
	public void showUpdates(){
		DataPane dp;
		int numpanes=rows.size();

		masterrow.repaint();

		for(int pcount=0;pcount<numpanes; pcount++){
			dp=(DataPane)rows.elementAt(pcount);
			dp.repaint();
		}
	}

	public Dimension getPreferredSize(){
		return preferredsize;
	}
	public Dimension getMinimumSize(){
		return getPreferredSize();
	}

	/** This is "public", but should not be used publically
	 * private gets called by internal objects for mouseclicks.
	 * Changed to 'protected' to hide it from javadoc.
	 */
	protected void mouseClicked(java.awt.event.MouseEvent evt){
		DataPane sourceobj;
		sourceobj=(DataPane) evt.getComponent();
		int rownum=rows.indexOf(sourceobj);

		if(evt.isShiftDown() && (lastrowclicked!=-1)){
			int first, last;
			if(rownum<lastrowclicked){
				first=rownum;
				last=lastrowclicked;
			} else {
				first=lastrowclicked;
				last=rownum;
			}
			while(first<=last){
				setHighlight(first++, true);
			}
			lastrowclicked=rownum;
			return;
		}

		if(!evt.isControlDown()){
			internalclearhighlights(false);
		}

		if(sourceobj.highlighted==false){
			sourceobj.setHighlighted(true);
		} else {
			sourceobj.setHighlighted(false);
		}

		lastrowclicked=rownum;

	}

	/** Irritating workaround for race condition issue in
	 * parent container Panel.
	 * If we create rows while parent is in BUSY cursor...
	 * cursor for each row does not get reset to normal,
	 * when parent sets cursor to non-busy again!
	 */
	public void resetCursor(){
		DataPane dp;
		int numpanes=rows.size();
		if(numpanes==0) return;
		for(int pcount=0;pcount<numpanes; pcount++){
			dp=(DataPane)rows.elementAt(pcount);
			dp.setCursor(Cursor.getDefaultCursor());
		}
	}

	/* "clear last" means "clear memory of last row clicked on" */
	void internalclearhighlights(boolean clearlast){
		DataPane dp;
		int numpanes=rows.size();
		if(numpanes==0) return;

		if(clearlast){
			lastrowclicked=-1;
		}
		for(int pcount=0;pcount<numpanes; pcount++){
			dp=(DataPane)rows.elementAt(pcount);
			dp.setHighlighted(false);
		}
	}

	/* internal utility function only */
	void setHighlight(int rownum, boolean value){
		if(rownum>=rows.size()) return;
		DataPane dp=(DataPane)rows.elementAt(rownum);
		dp.setHighlighted(value);
	}

	/* This is really written for the future, when and if
	 * we support having multiple rows highlighted
	 */
	public void clearHighlights(){
		internalclearhighlights(true);
	}

	/** simply unsets the "highlight" bit on the given data row.
	 *  It is not an error to call this on a row that was not
	 *  already highlighted.
	 */
	public void clearHighlight(int rownum){
		if(rownum>=rows.size()) return;
		DataPane dp=(DataPane)rows.elementAt(rownum);
		dp.setHighlighted(false);
		if(rownum==lastrowclicked)
			lastrowclicked=-1;
	}

	/** This will return the row number of the "first" row
	 * highlighted. returns -1 if none highlighted.
	 *
	 * Use this in conjunction with clearHighlight to walk through
	 * the case of multiple lines highlighted
	 */
	public int getHighlightedIndex(){
		final int none_set=-1;
		DataPane dp;
		int numpanes=rows.size();
		if(numpanes==0) return none_set;
		
		for(int pcount=0;pcount<numpanes; pcount++){
			dp=(DataPane)rows.elementAt(pcount);
			if(dp.highlighted){
				return pcount;
			}
		}
		return none_set;
	}
	/** Similar to getHighlightedIndex, except returns the
	 * actual String[] that the first highlighted row contains.
	 * (or returns null, if non set)
	 */
	public String[] getHighlightedRow(){
		DataPane dp;
		int numpanes=rows.size();
		if(numpanes==0) return null;
		
		for(int pcount=0;pcount<numpanes; pcount++){
			dp=(DataPane)rows.elementAt(pcount);
			if(dp.highlighted){
				return dp.values;
			}
		}
		return null;
	}

	
	/** This drops all the "rows", but PRESERVES the column header names
	 * and sizes.
	 */
	public void clearValues(){
		Component tmppanel=null;

		while(!rows.isEmpty()){
			tmppanel=(Component)rows.remove(0);
			remove(tmppanel);
			// We have to manually unlink each pane from our
			// visual object list. Cant just removeAllElements()
		}

		tmppanel=null;

		preferredsize.height=50;
	}


	/**
	 * Add a new "data row" created around the string array passed in
	 * Note that the size of the array must
	 * exactly match the number of rows the Listor was created for.
	 * 
	 * Note also that the array is passed by reference, not copied.
	 * Later changes to the values in the array, will affect the row
	 * created for it, although you will have to call
	 *  showUpdates for the Listor object to show the new values.
	 *
	 * @param vals contains data for each column in the row/line
	 *
	 */
	public void addValues(String vals[]){
		if( vals.length!=numcols){
			System.err.println("ERR: addvalues called with non-matching array");
			return;
		}

		DataPane dp = new DataPane(colwidths, vals, preferredsize.width-10);

		System.out.println("addValues HARDCODING preferred height");
		preferredsize.height+=30;
		dp.setBackground(databg);
		dp.addMouseListener(this);

		add(dp,constraints);
		rows.addElement(dp);
	}


	/** Set "top row" background color */
	public void setMasterBG(Color c){
		if(masterrow==null) return; // should never happen
		masterrow.setBackground(c);
	}
	
	/** Set default "data row" background color, and also
	 * update any existing data rows.
	 */
	public void setDataBG(Color c){
		databg=c;

		DataPane dp;
		int numpanes=rows.size();
		if(numpanes==0) return;
		
		for(int pcount=0;pcount<numpanes; pcount++){
			dp=(DataPane)rows.elementAt(pcount);
			dp.setBackground(databg);
		}

	}


	/** Set the name of a specific column.
	 * This gets stored in the internal "master row"
	 */
	public void setColName(int colnum, String name){
		if(colnum>=numcols){
			System.err.println("ERR: setColName called with col=" + colnum);
			return;
		}
		colnames[colnum]=name;

		/* XXX redraw? */
	}
	/** Set the width of a specific column, different from the default.
	 * This gets stored in an instance-global array.
	 */
	public void setColWidth(int colnum, int width){
		if(colnum>=numcols){
			System.err.println("ERR: setColWidth called with col=" + colnum);
			return;
		}
		colwidths[colnum]=width;

	}

	
}