//Chloe Chao
//Parse a special homemade font file and allow for a noise factor.
//Translate text (A-Z) from the textfield into homemade font

import java.applet.*;
import java.awt.*;
import java.awt.image.*;
import java.net.*;
import java.util.*;
import java.io.*;

public class FontNoiseParser extends Applet implements Runnable {

public void init() {
  UNIT = 4;
  LEFT_MARGIN = 6;
  TOP_MARGIN = 30;
  alphabet = new Vector();
  toBeCoded = new String();
  noiseFactor = 0;

  Panel p = new Panel();
  p.setLayout(new GridLayout(0,3));
  //Create the URL textfield and place in view.
  makeUrlField();
  p.add("West", urlField);
  // Create the noise factor textfield.
  makeNoiseField();
  p.add("Center", noiseField);
  //Create the button and place in view.
			makeButton();
  p.add("East", button);

  // Use BorderLayout.
  BorderLayout b = new BorderLayout();
  setLayout(b);
  add( "North", p );
  //Create the display Image and place in view.
  makeImageCanvas();
  add( "South", imageCanvas );

  displayImage = createImage(size().width,size().height);
  offg = displayImage.getGraphics();
  offg.setColor( Color.white );
  imageCanvas.setImage(displayImage);
  imageCanvas.repaint();

  //Read in the homemade font file.
  fetch("http://acg.media.mit.edu/mas962/users/cchao/ps5/fontcode.txt");
  //fetch("file://C|/fontcode.txt");

  // Start the applet thread.
  thread = new Thread( this );
  thread.start();
}

public void start() {
  if (thread != null) {
    thread.resume();
  }
}

public void stop() {
  if (thread != null) {
    thread.suspend();
  }
}

public void destroy() {
  if(thread != null) {
    thread.stop();
  }
}

public void run() {
  try {
    while( true ) {
      coded( noiseFactor-(theta), toBeCoded.toUpperCase() );
      repaint();
      if( INC )
      theta+=(noiseFactor*0.1);
      else
      theta-=(noiseFactor*0.1);
      if( theta>=noiseFactor && INC) {
	      INC = false;
	      theta = noiseFactor;
	      thread.sleep(5*sleepRate);
	    }
	    else if( theta<=0 && !INC ) {
	      INC = true;
	      theta = 0.0;
	      thread.sleep(2*sleepRate);
	    }
	    else
      thread.sleep(sleepRate);
    }
  } catch (InterruptedException e) {}
}

public void update(Graphics g) {
    paint(g);
}

public void paint (Graphics g) {
  paintComponents(g);
  imageCanvas.setImage(displayImage);
  imageCanvas.repaint();
  g.drawImage(displayImage, 0, 0, this);
}

public boolean action(Event e, Object arg) {
  if (e.target == button) {
    toBeCoded = urlField.getText();

    Double tempDouble;
    if (noiseField.getText() != null)
      tempDouble = new Double(noiseField.getText());
    else
      tempDouble = new Double(0.0);

    noiseFactor = tempDouble.doubleValue();
if( noiseFactor!=0 && noiseFactor!=1.0 )
    noiseFactor = 1.0-tempDouble.doubleValue();
if( noiseFactor==1.0 )
noiseFactor=.05;
    offg = displayImage.getGraphics();
    coded( noiseFactor, toBeCoded.toUpperCase() ); //This guarantees uppercase.

    return true;
  }

  return false;
}

public Image noiseImage(double bf, CodeString cs1, int gx, int gy) {
 int dim  = UNIT*12;
 Image i2 = cs1.getImage();
 Graphics g2 = i2.getGraphics();
 g2.setColor( Color.white );
 g2.fillRect( 0, 0, dim, dim );

 if( bf==0 ) {
   g2.setColor( Color.black );
   for( int i=0; i<cs1.arcs.size();) {
     Point p = (Point)cs1.arcs.elementAt(i++);
     Point d = (Point)cs1.arcs.elementAt(i++);
     Point a = (Point)cs1.arcs.elementAt(i++);
     g2.drawArc( p.x*UNIT, p.y*UNIT, d.x*UNIT, d.y*UNIT, a.x, a.y );
   }
   for( int i=0; i<cs1.lines.size();) {
     Point b = (Point)cs1.lines.elementAt(i++);
     Point e = (Point)cs1.lines.elementAt(i++);
     g2.drawLine( b.x*UNIT, b.y*UNIT, e.x*UNIT, e.y*UNIT );
   }
   for( int i=0; i<cs1.serifs.size(); i++) {
     Polygon p = (Polygon)cs1.serifs.elementAt(i);
     g2.fillPolygon( p );
     g2.drawPolygon(p);
   }
 }
else {
  // Draw original.
if( bf<=0.5 )
g2.setColor( new Color( (float)(1.0-theta), (float)(1.0-theta), (float)(1.0-theta) ) );
else
g2.setColor( Color.black );
for( int i=0; i<cs1.lines.size();) {
    Point b = (Point)cs1.lines.elementAt(i++);
    Point e = (Point)cs1.lines.elementAt(i++);
    g2.drawLine( b.x*UNIT, b.y*UNIT, e.x*UNIT, e.y*UNIT );
 }

for( int i=0; i<cs1.arcs.size();) {
    Point p = (Point)cs1.arcs.elementAt(i++);
    Point d = (Point)cs1.arcs.elementAt(i++);
    Point a = (Point)cs1.arcs.elementAt(i++);
    g2.drawArc( p.x*UNIT, p.y*UNIT, d.x*UNIT, d.y*UNIT, a.x, a.y );
 }
if( bf<=0.5 )
 g2.setColor( Color.black );
 else
g2.setColor( new Color( (float)(1.0-theta), (float)(1.0-theta), (float)(1.0-theta) ) );
for( int i=0; i<cs1.serifs.size(); i++) {
    Polygon q = (Polygon)cs1.serifs.elementAt(i);
    g2.fillPolygon( q );
    g2.drawPolygon(q);
 }
}// end else
return i2;
//offg.drawImage( i2, gx, gy, this );
}

public void coded( double noise, String codeme ) {
  CodeString cs = null;
  //System.out.println("decoding: "+noise);
  if (noise < 0.0)
    noise = 0.0;
  else if (noise > 1.0)
    noise = 1.0;


  //Reset drawing coordinates to upper-left and clear screen
  int currx, curry;
  currx = LEFT_MARGIN;
  curry = TOP_MARGIN;
  offg.setColor( Color.white );
  offg.fillRect( 0, 0, this.size().width, this.size().height);
  //StringBuffer sb = new StringBuffer();
  for( int i=0; i<codeme.length(); i++ ) {
    char code = codeme.charAt( i );

    boolean searching = true;
    int j=0;
    while( searching && j<alphabet.size()) {
      cs = (CodeString)alphabet.elementAt( j );
      char key = cs.getCode();
      //System.out.println("KEY is: "+key );
      if( key == code ) {
	//					codestring = cs.codestring;
	searching = false;
	//System.out.println("found it: "+code);
      }
      j++;
    }
    if( searching ) {//Didn't find a match.
      // Add a space?
    }
    else {
      // Add the proper image to displayImage.
      noiseImage( noise, cs, currx, curry) ;
      offg.drawImage(cs.getImage(), currx, curry, this);

    }

    currx+=((11*UNIT)+(int)(((i%UNIT)*UNIT*10)*(noiseFactor-theta)));
    if( currx>(size().width-(12*UNIT)) ) {
      currx = LEFT_MARGIN+(int)(((i%UNIT)*UNIT*10)*(noiseFactor-theta));
      curry+=(12*UNIT);
    }


  }//end for each letter


}// end coded()


public void fetch (String address) {
  byte buf[] = null;

  Image img;
  Graphics gg;

  if (!alphabet.isEmpty())
    alphabet.removeAllElements();
  try {
    URL url = new URL(address);

    StreamTokenizer tokens = new StreamTokenizer(url.openStream());

    int token;


    tokens.ordinaryChar(';'); // signifies end of commands
    tokens.ordinaryChar('|'); // signifies eol
    tokens.whitespaceChars( '(', ')' );
    tokens.eolIsSignificant(true);
    tokens.commentChar('%');

    // Get first token.
    token = tokens.nextToken();

    //				      if (FILE_READABLE) {
    // While not eof
    while (token != tokens.TT_EOF) {
      // While not eol
      while ( token != tokens.TT_EOL ) {
	// Take the first character of the line as the letter.
	if( tokens.sval != null ) {
	  String codestr = tokens.sval;
	  char code = codestr.charAt(0);
	  //System.out.println("code: "+code);
	  Image ii=createImage(UNIT*12, UNIT*12 );
	  CodeString cs = new CodeString( code, UNIT, ii );
	  alphabet.addElement( cs );
	  img = cs.getImage();
	  gg = img.getGraphics();
	  gg.setColor( Color.black );
	  // Get the next token and start parsing for operators.
	  // I don't have any error-checking. Sorry.
	  //token = tokens.nextToken();
	  while( (token=tokens.nextToken())!='|' ) {
	    if( token == tokens.TT_WORD ) {
	      if (tokens.sval.equals( "serifs" )) {
		// Get the number of serifs to draw.
		//tokens.nextToken();
		//int numOfSerifs = (int)tokens.nval;
		//for(int i=0; i<numOfSerifs; i++) {
		while( (token= tokens.nextToken())!=';') {
		  int d, x, y;
		  if( tokens.sval.equals("nw") )
		    d=NW;
		  else if( tokens.sval.equals("ne") )
		    d=NE;
		  else if( tokens.sval.equals("se") )
		    d=SE;
		  else
		    d=SW;
		  tokens.nextToken();
		  x = (int)tokens.nval;
		  tokens.nextToken();
		  y = (int)tokens.nval;
		  drawSerifs( d, x*UNIT, y*UNIT, gg, cs );
		}//end while
		//}// end for
	      }//end if serifs
	      else if( tokens.sval.equals( "lines" )) {
		while( (token= tokens.nextToken())!=';') {
		  int x1, y1, x2, y2;
		  x1 = (int)tokens.nval;
		  tokens.nextToken();
		  y1 = (int)tokens.nval;
		  tokens.nextToken();
		  x2 = (int)tokens.nval;
		  tokens.nextToken();
		  y2 = (int)tokens.nval;
		  gg.drawLine( x1*UNIT, y1*UNIT, x2*UNIT, y2*UNIT );
		  cs.lines.addElement( new Point( x1, y1 ) );
		  cs.lines.addElement( new Point( x2, y2 ) );
		}//end while
	      }// end else if lines
	      else if( tokens.sval.equals( "arcs" )) {
		while( (token= tokens.nextToken())!=';') {
		  int x, y, w, h, start, end;
		  x = (int)tokens.nval;
		  tokens.nextToken();
		  y = (int)tokens.nval;
		  tokens.nextToken();
		  w = (int)tokens.nval;
		  tokens.nextToken();
		  h = (int)tokens.nval;
		  tokens.nextToken();
		  start = (int)tokens.nval;
		  tokens.nextToken();
		  end = (int)tokens.nval;
		  gg.drawArc( x*UNIT, y*UNIT, w*UNIT, h*UNIT, start, end );
		  cs.arcs.addElement( new Point( x, y) );
		  cs.arcs.addElement( new Point(w, h));
		  cs.arcs.addElement( new Point(start,end));
		}// end while
	      }// end else if arcs
	      else if( tokens.sval.equals( "polygon" )) {
		Polygon p = new Polygon();
		//Read in the points until you hit a ';'
		while( (token= tokens.nextToken())!=';') {
		  int x, y;
		  x = (int)tokens.nval;
		  token= tokens.nextToken();
		  y = (int)tokens.nval;
		  p.addPoint(x*UNIT,y*UNIT);
		}// end while
		gg.fillPolygon(p);
		gg.drawPolygon(p);
	      }// end else if polygon
	    }// end if TT.WORD
	  }// end while not "|"
	}// end if tokens.sval!=null
	token = tokens.nextToken();


      }//END while not EOL
      token = tokens.nextToken();
    }//END while not EOF
    //}//END if( FILE_READABLE )
    System.out.println("exited loop");
  }//END try
  catch (MalformedURLException e) {
    System.err.println(e);
    return;
  }
  catch (IOException e) {
    System.err.println(e);
    return;
  }
}

private void drawError() {
offg = displayImage.getGraphics();
offg.setColor( Color.white );
offg.fillRect( 0,0, size().width, size().height);
offg.setColor( Color.black );
offg.drawString( "", LEFT_MARGIN, TOP_MARGIN);
}

private void addFormComponent(int x, int y, int w, int h,
GridBagLayout grid, Component comp,
GridBagConstraints c) {
c.gridx = x;
c.gridy = y;
c.gridwidth = w;
c.gridheight = h;
grid.setConstraints(comp, c);
add(comp);
}

private void makeButton() {
button = new Button("apply noise factor.");
}

private void makeUrlField() {
urlField = new TextField(60);
urlField.setText("the quick brown fox jumps over the lazy dog");
}

private void makeNoiseField() {
noiseField = new TextField(10);
noiseField.setText("1.0");
}

private void makeImageCanvas() {
imageCanvas = new ImageCanvas();
}

private void drawSerifs( int direction, int x, int y, Graphics gf, CodeString cs ) {
  Polygon p = new Polygon();
  p.addPoint( x,y );
  switch(direction) {
  case NW:
    p.addPoint(x,y-(2*UNIT)); p.addPoint( x-(2*UNIT), y);
    break;
  case NE:
    p.addPoint(x+(2*UNIT), y); p.addPoint(x, y-(2*UNIT));
    break;
  case SE:
    p.addPoint(x, y+(2*UNIT)); p.addPoint(x+(2*UNIT), y);
    break;
  case SW:
    p.addPoint(x-(2*UNIT), y); p.addPoint(x, y+(2*UNIT));
    break;
  default:
    break;

  }// end switch
  p.addPoint(x,y);
  gf.fillPolygon(p);
  gf.drawPolygon(p);
  cs.addSerif(p);
}

private Button button;
private TextField urlField, noiseField;
private ImageCanvas imageCanvas;
private Image displayImage;
private Graphics offg;
private Vector alphabet;
private Thread thread;
private String toBeCoded;
private double noiseFactor;
private double theta = 0.0;
private boolean INC = true;
private boolean FILE_READABLE = true;
private int LEFT_MARGIN;
private int TOP_MARGIN;
private int UNIT; //This sets the scale of homemade font.
public static final int NW = 0;
public static final int NE = 1;
public static final int SE = 2;
public static final int SW = 3;
public static final int sleepRate = 100; // sleep between redraw in milliseconds

private StringBuffer strBuff;

}//end FontParser

//All the letters of the homemade font are 8x8 so to allow
//for overreach make Image 12x12
class CodeString extends Object {
char code;
Image i;
int u;
public Vector lines, serifs, arcs;
public CodeString( char code, int unit, Image image ) {
this.code = code;
this.u = unit;
this.i = image;
Graphics g= i.getGraphics();
g.setColor( Color.white );
g.fillRect( 0, 0, u*12, u*12 );
lines = new Vector();
serifs = new Vector();
arcs = new Vector();
}

public void addSerif( Polygon p ) {
serifs.addElement(p);
}

public char getCode() {
	return this.code;
}

public Image getImage() {
return this.i;
}
}

class ImageCanvas extends Canvas {
Image image;
public ImageCanvas () {
}
public void setImage( Image image ) {
this.image = image;
}
public void paint( Graphics g ) {
g.drawImage(this.image, 0, 0, this);
}
}