/*
 * Adapted 10/98 by Sean Kessler
 * Added arrow key navigation
 * Added cell scrolling
 * Fixed drawing routines
 * Removed applet extension
 * Created Interface instantiation class with user interface methods
 * Fixed Strings
 *
 * @(#)SpreadSheet.java 1.17 95/03/09 Sami Shaio
 *
 * Copyright (c) 1994-1995 Sun Microsystems, Inc. All Rights Reserved.
 *
 * Permission to use, copy, modify, and distribute this software
 * and its documentation for NON-COMMERCIAL or COMMERCIAL purposes and
 * without fee is hereby granted. 
 * Please refer to the file http://java.sun.com/copy_trademarks.html
 * for further important copyright and trademark information and to
 * http://java.sun.com/licensing.html for further important licensing
 * information for the Java (tm) Technology.
 * 
 * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
 * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
 * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
 * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
 * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
 * 
 * THIS SOFTWARE IS NOT DESIGNED OR INTENDED FOR USE OR RESALE AS ON-LINE
 * CONTROL EQUIPMENT IN HAZARDOUS ENVIRONMENTS REQUIRING FAIL-SAFE
 * PERFORMANCE, SUCH AS IN THE OPERATION OF NUCLEAR FACILITIES, AIRCRAFT
 * NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL, DIRECT LIFE
 * SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH THE FAILURE OF THE
 * SOFTWARE COULD LEAD DIRECTLY TO DEATH, PERSONAL INJURY, OR SEVERE
 * PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH RISK ACTIVITIES").  SUN
 * SPECIFICALLY DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR
 * HIGH RISK ACTIVITIES.
 */
import java.applet.Applet;
import java.awt.*;
import java.io.*;
import java.net.*;

//******************************************************************************************************
// ***************************************** SPREADSHEET ***********************************************
//******************************************************************************************************

public class SpreadSheetInterface
{
  SpreadSheet mSpreadSheet;

	public SpreadSheetInterface(Applet applet,int rows,int columns)
	{
	  mSpreadSheet=new SpreadSheet(applet,rows,columns,applet.size());
	}
	public SpreadSheetInterface(Applet applet,int rows,int columns,Dimension controlDimension)
	{
	  mSpreadSheet=new SpreadSheet(applet,rows,columns,controlDimension);
	}
	public void update(Graphics graphics)
	{
	  mSpreadSheet.update(graphics);
	}
  public void paint(Graphics graphics)
  {
	  mSpreadSheet.paint(graphics);
  }
	public boolean mouseDown(Event event,int x,int y)
	{
	  return mSpreadSheet.mouseDown(event,x,y);
	}
  public boolean keyDown(Event event,int key)
	{
	  return mSpreadSheet.keyDown(event,key);
	}
	public boolean setCellData(int row,int col,String strData)
	{
	  return mSpreadSheet.setCellData(row,col,strData);
	}
	public boolean setCellData(int row,int col,String strData,boolean repaint)
	{
	  return mSpreadSheet.setCellData(row,col,strData,repaint);
	}
	public void repaint()
	{
	  mSpreadSheet.applet().repaint();
	}
	public void setDocumentTitle(String strDocumentTitle)
	{
	  mSpreadSheet.setDocumentTitle(strDocumentTitle);
	}
	public void clear()
	{
	  mSpreadSheet.init();
	}
	public void gridLock(boolean gridLock)
	{
	  mSpreadSheet.gridLock(gridLock);
	}
}
class SpreadSheet
{
  private final Dimension mCellDimension=new Dimension(100,15);
	private Dimension mControlDimension;
  private String mStrTitle;
  private Font mTitleFont;
  private Color mCellColor;
  private Color mInputColor;
  private int mTitleHeight=15;
  private int mRowLabelWidth=24;
  private boolean mIsStopped=false;
  private boolean mFullUpdate=true;
  private int mRows;
  private int mColumns;
  private int mSelectedRow;
  private int mSelectedColumn;
  private SpreadSheetInput mInputArea;
  private Cell mCells[][];
  private Cell mCurrent=null;
  private int mStartDisplayRow;
	private int mStartDisplayColumn;
	private Applet mApplet;
	private boolean mGridLock;

  public SpreadSheet(Applet applet,int rows,int cols,Dimension controlDimension)
	{
    String strParam;

    mApplet=applet;
		mGridLock=false;
		mControlDimension=controlDimension;
    mCellColor=Color.white;
    mInputColor=new Color(100,100,225);
    mTitleFont=new Font("Courier", Font.BOLD, 12);
    mStrTitle=mApplet.getParameter("title");
		if(null==mStrTitle)mStrTitle="SpreadSheet";
		mRows=rows;
		mColumns=cols;
    mCells=new Cell[mRows][mColumns];
		init();
    mInputArea=new SpreadSheetInput(null,mApplet,this,mControlDimension.width-2,mCellDimension.height-1,mInputColor,Color.white); 
    mApplet.resize(mColumns*mCellDimension.width+mRowLabelWidth,((mRows+1)*mCellDimension.height)+mCellDimension.height+mTitleHeight);
  }
	public void init()
	{
		char strLabel[]=new char[1];

		deselect(true);
    for(int row=0;row<mRows;row++)
		{
      for(int col=0;col<mColumns;col++)
			{
			  mCells[row][col]=new Cell(this,Color.lightGray,Color.black,mCellColor,mCellDimension.width-2,mCellDimension.height-2);
        strLabel[0]=(char)((int)'a'+col);
      }
    }
    mStartDisplayRow=0;
		mStartDisplayColumn=0;
		mSelectedRow=-1;
		mSelectedColumn=-1;
		mFullUpdate=true;
		mApplet.repaint();
	}
  public void stop()
	{
	  stopped(true);
  }
  public void start()
	{
	  stopped(false);
  }
	public void stopped(boolean stopped)
	{
	  mIsStopped=stopped;
	}
	public boolean stopped()
	{
	  return mIsStopped;
	}
  public void destroy()
	{
  }
  public void setCurrentValue(float val)
	{
	  if(-1==mSelectedRow||-1==mSelectedColumn)return;
    mCells[mSelectedRow][mSelectedColumn].setValue(val);
    mApplet.repaint();
  }
  public void setCurrentValue(int type,String val)
	{
	  if(-1==mSelectedRow||-1==mSelectedColumn)return;
    mCells[mSelectedRow][mSelectedColumn].setValue(type,val);
    mApplet.repaint();
  }
  public void update(Graphics graphics)
	{
	  if(mFullUpdate)
		{
      paint(graphics);
      mFullUpdate=false;
			return;
		}
    graphics.setFont(mTitleFont);
		drawCells(graphics,false);
  }
  public synchronized void paint(Graphics graphics)
	{
		char strLabel[]=new char[1];

    graphics.setFont(mTitleFont);
    graphics.drawString(mStrTitle,(mControlDimension.width-graphics.getFontMetrics().stringWidth(mStrTitle))/2,12);
    graphics.setColor(mInputColor);
		drawGrid(graphics);
		drawCells(graphics,true);
    graphics.setColor(mApplet.getBackground());
    graphics.draw3DRect(0,mTitleHeight,mControlDimension.width,mControlDimension.height-mTitleHeight,false);
		mInputArea.paint(graphics,1,mTitleHeight+1);
  }
	public void drawGrid(Graphics graphics)
	{
	  int i;
		int cy;
		int cx;

    for(i=0;i<mRows+1;i++)
		{
      cy=((i+2)*mCellDimension.height);
			if(cy+2>mControlDimension.height)continue;
      graphics.setColor(mApplet.getBackground());
			graphics.draw3DRect(0,cy,mControlDimension.width,2,true);
			if(cy+mCellDimension.height>mControlDimension.height)continue;
      if(i<mRows)
			{
        graphics.setColor(mApplet.getBackground());
				graphics.fillRect(1,cy+1,mRowLabelWidth-1,(2*mCellDimension.height)-2);
        graphics.setColor(Color.red);
				graphics.drawString(""+(i+1+mStartDisplayRow),2,cy+12);
      }
    }
    graphics.setColor(Color.red);
    for(i=0;i<mColumns;i++)
		{
      cx=i*mCellDimension.width;
			if(cx>mControlDimension.width)continue;
      graphics.setColor(mApplet.getBackground());
			graphics.draw3DRect(cx+mRowLabelWidth,2*mCellDimension.height,1,mControlDimension.height-(2*mCellDimension.height),true);
    }
	}
	public void drawCells(Graphics graphics,boolean updateAll)
	{
	  int i;
		int j;
		int cx;
		int cy;
		boolean inDraw=true;
		
		for(i=mStartDisplayRow;i<mRows&inDraw;i++)
		{
      for(j=mStartDisplayColumn;j<mColumns&&inDraw;j++)
			{
			  if(updateAll||(!updateAll&&mCells[i][j].needRedisplay()))
				{
          cx=((j-mStartDisplayColumn)*mCellDimension.width)+2+mRowLabelWidth;
          cy=((i+1-mStartDisplayRow)*mCellDimension.height)+2+mTitleHeight;
					if(cy>mControlDimension.height)inDraw=false;
				  if(mCells[i][j]!=null)mCells[i][j].paint(graphics,cx,cy);
				}
      }
    }
	}
  public void recalculate()
	{
    for(int row=0;row<mRows;row++)
		{
      for(int col=0;col<mColumns;col++)
			{
        if(mCells[row+mStartDisplayRow][col+mStartDisplayColumn]!=null&&mCells[row+mStartDisplayRow][col+mStartDisplayColumn].type()==Cell.FORMULA)
				{
          mCells[row+mStartDisplayRow][col+mStartDisplayColumn].setRawValue(evaluateFormula(mCells[row+mStartDisplayRow][col+mStartDisplayColumn].parseRoot()));
          mCells[row+mStartDisplayRow][col+mStartDisplayColumn].needRedisplay(true);
        }
      }
    }
		mApplet.repaint();
  }
  private float evaluateFormula(Node node)
	{
    float val=0.0f;

		if(null==node)return val;
    switch(node.type())
		{
      case Node.OP:
        val=evaluateFormula(node.left());
        switch(node.op())
				{
          case '+':
            val += evaluateFormula(node.right());
            break;
          case '*':
            val *= evaluateFormula(node.right());
            break;
          case '-':
            val -= evaluateFormula(node.right());
            break;
          case '/':
            val /= evaluateFormula(node.right());
            break;
        }
        break;
      case Node.VALUE:
			  val=node.value();
				break;
      case Node.CELL:
		    if(null==node)break;
				if(null==mCells[node.row()][node.column()])break;
				val=mCells[node.row()][node.column()].value();
				break;
   }
    return val;
  }   
  public boolean mouseDown(Event evt,int x,int y)
	{
    if(y<(mTitleHeight+mCellDimension.height))
		{
		  mSelectedRow=-1;
			if(y<=mTitleHeight)deselect(true);
      return true;
    }
    if(x<mRowLabelWidth)
		{
		  mSelectedRow=-1;
			deselect(true);
      return true;
    }
    mSelectedRow=((y-mCellDimension.height-mTitleHeight)/mCellDimension.height)+mStartDisplayRow;
    mSelectedColumn=((x-mRowLabelWidth)/mCellDimension.width)+mStartDisplayColumn;
    if(mSelectedRow>=mRows||mSelectedColumn>=mColumns)
		{
      mSelectedRow=-1;
			deselect(true);
			return true;
    }
    if(((mSelectedRow-mStartDisplayRow+2)*mCellDimension.height)+2+mTitleHeight>mControlDimension.height)
		{
		  mSelectedRow=-1;
			deselect(true);
			return true;
		}
		if(((mSelectedColumn-mStartDisplayColumn)*mCellDimension.width)+2+mRowLabelWidth+mCellDimension.width>mControlDimension.width)
		{
		  mSelectedColumn=-1;
			deselect(true);
			return true;
		}
		select();
    return true;
  }
  public boolean keyDown(Event evt, int key)
	{
		if(Key.LeftArrow==key||Key.RightArrow==key||Key.UpArrow==key||Key.DownArrow==key)
		{
		  if(!gridLock()){mInputArea.keyDown(Key.Return);mFullUpdate=true;}
			navigate(key);
		}
		else if(!gridLock()){mInputArea.keyDown(key);mFullUpdate=true;}
    return true;
  }
	private void navigate(int key)
	{
	  switch(key)
		{
		  case Key.LeftArrow :
			  if(mSelectedColumn<=0)break;
				mSelectedColumn--;
				ensureVisible();
				select();
			  break;
			case Key.RightArrow :
			  if(mSelectedColumn+1>=mColumns)break;
				mSelectedColumn++;
				ensureVisible();
				select();
			  break;
			case Key.UpArrow :
			  if(mSelectedRow<=0)break;
				mSelectedRow--;
				ensureVisible();
				select();
			  break;
			case Key.DownArrow :
			  if(mSelectedRow+1>=mRows)break;
				mSelectedRow++;
				ensureVisible();
				select();
			  break;
		}
	}
	private void select()
	{
	  Cell cell=mCells[mSelectedRow][mSelectedColumn];

		if(null!=cell.getPrintString())mInputArea.setText(new String(cell.getPrintString()));
		else mInputArea.setText(new String(""));
    if(mCurrent!=null)mCurrent.deselect();
    mCurrent=cell;
    mCurrent.select();
    mApplet.requestFocus();
    mFullUpdate=true;
    mApplet.repaint();
	}
	private void deselect(boolean destroy)
	{
	  if(null==mCurrent)return;
		mCurrent.deselect();
		if(destroy)mCurrent=null;
	}
  private void ensureVisible()
	{
    int yMin=(2*mCellDimension.height)+2+mTitleHeight;
		int xMin=2+mRowLabelWidth+mCellDimension.width;
	  Point currPoint=new Point(0,0);
		
    currPoint.y=((mSelectedRow-mStartDisplayRow+2)*mCellDimension.height)+2+mTitleHeight;
		currPoint.x=((mSelectedColumn-mStartDisplayColumn)*mCellDimension.width)+2+mRowLabelWidth+mCellDimension.width;
		if(currPoint.y>mControlDimension.height)mStartDisplayRow++;
		else if(currPoint.y<yMin)mStartDisplayRow--;
		if(currPoint.x>mControlDimension.width)mStartDisplayColumn++;
		else if(currPoint.x<xMin)mStartDisplayColumn--;
	}
	public Applet applet()
	{
	  return mApplet;
	}
	public Dimension controlDimension()
	{
	  return mControlDimension;
	}
	public int rows()
	{
	  return mRows;
	}
	public int columns()
	{
	  return mColumns;
	}
	public boolean setCellData(int row,int col,String strData)
	{
	  return setCellData(row,col,strData,true);
	}
	public boolean setCellData(int row,int col,String strData,boolean repaint)
	{
	  String strCellData;
	  if(row>=mRows||col>=mColumns)return false;
		strCellData="l";
		strCellData+=strData;
		mCells[row][col].setUnparsedValue(strCellData);
	  if(repaint)mApplet.repaint();
		return true;
	}
	public void setDocumentTitle(String strDocumentTitle)
	{
	  mStrTitle=strDocumentTitle;
	}
	public void gridLock(boolean gridLock)
	{
	  mGridLock=gridLock;
	}
	public boolean gridLock()
	{
	  return mGridLock;
	}
}

//******************************************************************************************************
// ******************************************** CELL ***************************************************
//******************************************************************************************************
class Cell
{
  public static final int VALUE = 0;
  public static final int LABEL = 1;
  public static final int URL   = 2;
  public static final int FORMULA = 3;

  private final int mMaxDisplayLength=14;    
  private Node mParseRoot;
  private boolean mNeedRedisplay;
  private boolean mSelected = false;
  private boolean mTransientValue = false;
  private int mType=Cell.VALUE;
  private String mValueString = "";
  private String mPrintString = "v";
  private float mValue;
  private Color mBgColor;
  private Color mFgColor;
  private Color mHighlightColor;
  private int mWidth;
  private int mHeight;
  private SpreadSheet mSpreadSheet;
  private boolean mPaused=false;

  public Cell(SpreadSheet spreadSheet,Color bgColor,Color fgColor,Color highlightColor,int width,int height)
	{
	  mSpreadSheet=spreadSheet;
		mBgColor=bgColor;
    mFgColor=fgColor;
    mHighlightColor=highlightColor;
    mWidth=width;
    mHeight=height;
    mNeedRedisplay=true;
  }
  public void setRawValue(float value)
	{
    mValueString=Float.toString(value);
    mValue=value;
  }
  public void setTransientValue(float value)
	{
    mTransientValue=true;
    mValue=value;
    mNeedRedisplay=true;
    mSpreadSheet.recalculate();
  }
  public void setUnparsedValue(String s)
	{
    switch (s.charAt(0))
	  {
      case 'v':
        setValue(Cell.VALUE,s.substring(1));
        break;
      case 'f':
        setValue(Cell.FORMULA,s.substring(1));
        break;
      case 'l':
        setValue(Cell.LABEL,s.substring(1));
        break;
      case 'u':
        setValue(Cell.URL, s.substring(1));
        break;
    }
  }
  public String parseFormula(String formula, Node node)
	{
    String subformula;
    String restFormula;
    float value;
    int length = formula.length();
    Node left;
    Node right;
    char op;

	  if(null==formula)return null;
    subformula=parseValue(formula, node);
		if(null==subformula||0==subformula.length())return null;
		if(subformula==formula)return formula;
    switch(op=subformula.charAt(0))
		{
      case 0:
        return null;
      case ')':
        return subformula;
      case '+':
      case '*':
      case '-':
      case '/':
        restFormula = subformula.substring(1);
        subformula = parseValue(restFormula, right=new Node());
        if(subformula != restFormula)
				{
          left = new Node(node);
          node.left(left);
          node.right(right);
          node.op(op);
          node.type(Node.OP);
          return subformula;
        }
				else return formula;
      default:
        return formula;
    }
  }
  public String parseValue(String formula, Node node)
	{
    char c=formula.charAt(0);
    String subformula;
    String restFormula;
    float value;
    int row;
    int column;

    restFormula = formula;
    if (c == '(')
		{
      restFormula = formula.substring(1);
      subformula = parseFormula(restFormula, node);
      if(subformula == null || subformula.length() == restFormula.length())return formula;
      else if (! (subformula.charAt(0) == ')'))return formula;
      restFormula = subformula;
    }
	  else if (c >= '0' && c <= '9')
		{ 
      int i;

      try{value = Float.valueOf(formula).floatValue();}
			catch (NumberFormatException exception){return formula;}
      for (i=0; i < formula.length(); i++)
			{
        c = formula.charAt(i);
        if ((c < '0' || c > '9') && c != '.')break;
      }
      node.type(Node.VALUE);
      node.value(value);
      restFormula = formula.substring(i);
      return restFormula;
    }
		else if (c >= 'A' && c <= 'Z')
		{
      int i;

      column = c - 'A';
      restFormula = formula.substring(1);
      row = Float.valueOf(restFormula).intValue();
      for(i=0; i < restFormula.length(); i++)
			{
        c = restFormula.charAt(i);
        if (c < '0' || c > '9')break;
      }
      node.row(row-1);
      node.column(column);
      node.type(Node.CELL);
      if (i == restFormula.length())restFormula=null;
			else
			{
        restFormula = restFormula.substring(i);
        if (restFormula.charAt(0) == 0)return null;
      }       
    }
    return restFormula;
  }
  public void setValue(float value)
	{
    setRawValue(value);
    mPrintString="v"+mValueString;
    mType=Cell.VALUE;
    mPaused=false;
    mSpreadSheet.recalculate();
    mNeedRedisplay=true;
  }
  public void setValue(int type, String s)
	{
    mPaused=false;
	  mValueString=new String(s);
		mType=type;
		mNeedRedisplay=true;
    switch(mType)
		{
      case Cell.VALUE:
        setValue(Float.valueOf(s).floatValue());
        break;
      case Cell.LABEL:
        mPrintString = "l" + mValueString;
        break;
      case Cell.URL:
        mPrintString = "u" + mValueString;
        break;
      case Cell.FORMULA:
        parseFormula(mValueString,mParseRoot=new Node());
        mPrintString = "f" + mValueString;
        break;
    }
		mSpreadSheet.recalculate();
  }
	public String getValueString()
	{
    return mValueString;
  }
  public String getPrintString()
	{
    return mPrintString;
  }
  public void select()
	{
    mSelected=true;
		mPaused=true;
  }
  public void deselect()
	{
    mSelected=false;
		mPaused=false;
    mNeedRedisplay=true;
    mSpreadSheet.applet().repaint();
  }
  public void paint(Graphics graphics,int x,int y)
	{
    if(mSelected)graphics.setColor(mHighlightColor);
	  else graphics.setColor(mBgColor);
    graphics.fillRect(x+1,y+1,mWidth-1,mHeight-1);
		if(null==mValueString)return;
    switch(mType)
		{
      case Cell.VALUE:
      case Cell.LABEL:
        graphics.setColor(mFgColor);
        break;
      case Cell.FORMULA:
        graphics.setColor(Color.red);
        break;
      case Cell.URL:
        graphics.setColor(Color.blue);
        break;
    }
		String printString;
		if(!mTransientValue)
		{
		  if(mValueString.length()>mMaxDisplayLength)printString=new String(mValueString.substring(0,mMaxDisplayLength));
			else printString=new String(mValueString);
		}
		else printString=new String(""+mValue);
		FontMetrics metrics=graphics.getFontMetrics();
		int stringWidth=metrics.stringWidth(printString);

    if(x+stringWidth<mSpreadSheet.controlDimension().width&&
		   y+(mHeight/2)+5<mSpreadSheet.controlDimension().height   ) graphics.drawString(printString,x,y+(mHeight/2)+5);
//    if(x+stringWidth<mSpreadSheet.controlDimension().width)graphics.drawString(printString,x,y+(mHeight/2)+5);
    mNeedRedisplay=false;
  }
	public int type()
	{
	  return mType;
	}
	public Node parseRoot()
	{
	  return mParseRoot;
	}
	public void needRedisplay(boolean needRedisplay)
	{
	  mNeedRedisplay=needRedisplay;
	}
	public boolean needRedisplay()
	{
	  return mNeedRedisplay;
	}
	public float value()
	{
	  return mValue;
	}
	public SpreadSheet spreadSheet()
	{
	  return mSpreadSheet;
	}
	public boolean paused()
	{
	  return mPaused;
	}
}
//******************************************************************************************************
// ***************************************  NODE *******************************************************
//******************************************************************************************************
class Node
{
  public static final int OP = 0;
  public static final int VALUE = 1;
  public static final int CELL = 2;
  private int mType;
  private Node mLeft;
  private Node mRight;
  private int mRow;
  private int mColumn;
  private float mValue;
  private char mOp;

  public Node()
	{
    mLeft=null;
    mRight=null;
    mValue=0;
    mRow=-1;
    mColumn=-1;
    mOp=0;
		mType=Node.VALUE;
  }
  public Node(Node node)
	{
    mLeft=node.mLeft;
    mRight=node.mRight;
    mValue=node.mValue;
    mRow=node.mRow;
    mColumn=node.mColumn;
    mOp=node.mOp;
		mType=node.mType;
  }
  public void print(int indentLevel)
	{
    char l[] = new char[1];
    switch(mType)
		{
      case Node.VALUE:
        break;
      case Node.CELL:
        l[0] = (char)((int)'A' + column());
        break;
      case Node.OP:
        mLeft.print(indentLevel + 3);
        mRight.print(indentLevel + 3);
        break;
    }
  }
	public int type()
	{
	  return mType;
	}
	public void type(int type)
	{
	  mType=type;
	}
	public float value()
	{
	  return mValue;
	}
	public void value(float value)
	{
	  mValue=value;
	}
	public Node left()
	{
	  return mLeft;
	}
	public void left(Node left)
	{
	  mLeft=left;
	}
	public Node right()
	{
	  return mRight;
	}
	public void right(Node right)
	{
	  mRight=right;
	}
	public char op()
	{
	  return mOp;
	}
	public void op(char op)
	{
	  mOp=op;
	}
	public int row()
	{
	  return mRow;
	}
	public void row(int row)
	{
	  mRow=row;
	}
	public int column()
	{
	  return mColumn;
	}
	public void column(int column)
	{
	  mColumn=column;
	}
}

class InputField
{
  private int mMaxChars=50;
  private Applet mApplet;
  private String mStringValue;
  private char mBuffer[];
  private int mChars;
  private int mWidth;
  private int mHeight;
	private Color mBgColor;
	private Color mFgColor;

  public InputField(String initValue,Applet applet,int width,int height,Color bgColor, Color fgColor)
	{
	  mWidth=width;
		mHeight=height;
		mBgColor=bgColor;
		mFgColor=fgColor;
		mApplet=applet;
    mBuffer=new char[mMaxChars];
    mChars=0;
    if(initValue!=null)
		{
      initValue.getChars(0,initValue.length(),mBuffer,0);
      mChars=initValue.length();
    }
    mStringValue=initValue;
  }
  public void setText(String val)
	{
    if(val==null)
		{
      mStringValue=new String("");
      mChars=0;
      mBuffer[0]=0;
			return;
    }
		int index;
    for(index=0;index<mMaxChars;index++)mBuffer[index]=0;
    int valLength=val.length();
    val.getChars(0,valLength>=mMaxChars?mMaxChars-1:valLength,mBuffer,0);
		for(index=0;mBuffer[index]!=0&&index<mMaxChars;index++);
		mChars=index;
		mStringValue=new String(mBuffer).substring(0,index);
  }
  public String getValue()
	{
	  return mStringValue;
  }
  public void paint(Graphics g,int x,int y)
	{
    g.setColor(mBgColor);
    g.fillRect(x,y,mWidth,mHeight);
    if(null!=mStringValue)
		{
      g.setColor(mFgColor);
      g.drawString(mStringValue,x,y+(mHeight/2)+3);
    }
  }
  public void mouseUp(int x, int y)
	{
  }
  public void keyDown(int key)
	{
    if(mChars<mMaxChars)
		{
      switch(key)
			{
        case Key.BackSpace :
          --mChars;
          if(mChars<0)mChars=0;
          mBuffer[mChars] = 0;
          mStringValue=new String(new String(mBuffer));
          break;
        case Key.Return :
				  selected();
          break;
        default:
          mBuffer[mChars++]=(char)key;
          mStringValue=new String(new String(mBuffer));
          break;
      }
    }
		mApplet.repaint();
  }
  public void selected()
	{
  }
	public Applet applet()
	{
	  return mApplet;
	}
}

class SpreadSheetInput extends InputField
{
  SpreadSheet mSpreadSheet;

  public SpreadSheetInput(String initValue,Applet app,SpreadSheet spreadSheet,int width,int height,Color bgColor,Color fgColor)
	{
    super(initValue,app,width,height,bgColor,fgColor);
	  mSpreadSheet=spreadSheet;
  }
	public void selected()
	{
    float f;
    
		if(null==getValue())return;
	  switch(getValue().charAt(0))
		{
      case 'v':
        try{f=Float.valueOf(getValue().substring(1)).floatValue();mSpreadSheet.setCurrentValue(f);} 
			  catch(Exception exception){;}
        break;
      case 'l':
			  try{mSpreadSheet.setCurrentValue(Cell.LABEL,getValue().substring(1));}
				catch(Exception exception){;}
        break;
      case 'u':
			  try{mSpreadSheet.setCurrentValue(Cell.URL,getValue().substring(1));}
				catch(Exception exception){;}
        break;
      case 'f':
			  try{mSpreadSheet.setCurrentValue(Cell.FORMULA,getValue().substring(1));}
				catch(Exception exception){;}
        break;
    }
  }
}

class Key
{
  public static final int LeftArrow=1006;
	public static final int RightArrow=1007;
	public static final int UpArrow=1004;
	public static final int DownArrow=1005;
	public static final int BackSpace=8;
	public static final int Return=10;
	public Key()
	{
	}
};