//******************************************************************************
// diffusion.java:	Applet
//
//******************************************************************************
import java.applet.*;
import java.awt.*;
import java.util.Random;
//import gjt.*;

//==============================================================================
// Main Class for applet diffusion
//
//==============================================================================
public class Frap3 extends Applet {
	ThreeDBorder tdb = null;
	Frap3CanvasN dc = null;
	BarChart theChartRed=null;
	Button StartStop=new Button("Start");
	boolean running=false;

	public void init(){
		dc = new Frap3CanvasN(this);
		tdb = new ThreeDBorder(dc,5);
		theChartRed=new BarChart(Color.red,"Number within Circle",75.0,0.0);
		tdb.inset();
		setLayout(new BorderLayout());
		add("Center",tdb);
		add("South",theChartRed);
		add("North",StartStop);
	}

	public Insets insets(){
		return new Insets(5,5,5,5);
	}

	public void start(){
		dc.init();
		//dc.start();
	}

	public void stop(){
		dc.stop();
	}

	public boolean action(Event event, Object what){
		if(event.target==StartStop){
			if (running){
				dc.stop();
				running=false;
				StartStop.setLabel("Start");
			}else{
				dc.start();
				running=true;
				StartStop.setLabel("Stop");
			}
		}
		return true;

	}



}



class Frap3CanvasN extends Canvas implements Runnable   //, StopwatchClient
{
	// THREAD SUPPORT:
	//		m_diffusion	is the Thread object for the applet
	//--------------------------------------------------------------------------
	Thread	m_diffusion = null;
	Thread	m_watch = null;
	private Applet applet;
	private final int NUM_PARTICLE=200;
	private final int CIRC_DIAM=80;
	private final double Fast=5.0, Slow=2.0;
	private Particle p[];

	private Graphics m_g,m_r;
	private Image m_image,m_ready;//  ,m_bg;
	private Dimension m_dimImage;
	private int Tick=0;
	private Color BG=new Color(153,204,204);
	private Point Start,UL,LR;
	private boolean ResetLocation=true;
	private boolean ImageReady=false;
	private int first=0, density=10, NumberIn1=0, NumberIn2=0;
	private int FrapCount=0;

	public Membrane m_Membrane;
	Circle m_circ;

	// diffusion Class Constructor
	//--------------------------------------------------------------------------
	public Frap3CanvasN(Applet applet)
	{
		this.applet=applet;
	}

	// APPLET INFO SUPPORT:
	//		The getAppletInfo() method returns a string describing the applet's
	// author, copyright date, or miscellaneous information.
    //--------------------------------------------------------------------------
	public String getAppletInfo()
	{
		return "Name: Frap diffusion\r\n" +
		       "Author: Joe Patlak\r\n" +
		       "Created with Microsoft Visual J++ Version 1.0";
	}


	// The init() method is called by the AWT when an applet is first loaded or
	// reloaded.  Override this method to perform whatever initialization your
	// applet needs, such as initializing data structures, loading images or
	// fonts, creating frame windows, setting the layout manager, or adding UI
	// components.
    //--------------------------------------------------------------------------
	public void init()
	{
		Dimension dim=size();
		int nWidth=dim.width;
		int nHeight=dim.height;
		Start= new Point(15,15);
		UL=new Point(0,0);
		LR=new Point(nWidth-5,nHeight-5);

		m_circ=new Circle(dim.width/2, dim.height/2,CIRC_DIAM);

		int charge=1;
		p = new Particle[NUM_PARTICLE];

		for (int i=0; i<NUM_PARTICLE; i++){
			p[i]= new Particle(applet,charge,Start,UL,LR);
			p[i].a_string="images/anion2.gif";
			p[i].m_StdDev=Fast;
			p[i].BG=getBackground();
			p[i].bouncing=false;
		}

		ResizeImage();
		//m_bg=applet.getImage(applet.getCodeBase(),"images/graphBkgnd.gif");


	}

	// Place additional applet clean up code here.  destroy() is called when
	// when you applet is terminating and being unloaded.
	//-------------------------------------------------------------------------
	public void destroy(){
	}

	// diffusion Paint Handler
	//--------------------------------------------------------------------------
	public void paint(Graphics g)
	{
		if (m_ready != null){
			g.drawImage(m_ready,0,0,null);
		}
	}

	//--------------------------------------------------------------------------
	public void update(Graphics g)
	{
		ResizeImage();
		paint(g);
		ImageReady=false;
	}


	//--------------------------------------------------------------------------
	private void ResizeImage(){
		Dimension dim = size();
		int nWidth = dim.width;
		int nHeight = dim.height;

		if (m_dimImage != null &&
			m_dimImage.width == nWidth &&
			m_dimImage.height == nHeight){

			return;
		}

		m_dimImage = new Dimension(nWidth, nHeight);
		m_image = createImage(nWidth, nHeight);
		m_ready = createImage(nWidth, nHeight);
		m_g = m_image.getGraphics();
		m_r = m_ready.getGraphics();
		LR=new Point(nWidth-5,nHeight-5);	
		for (int i=0; i<NUM_PARTICLE; i++){
			p[i].NewLimits(UL,LR);
		}
		m_circ=new Circle(dim.width/2, dim.height/2,CIRC_DIAM);

	}


	public Point NewEntry(){
		double t=Math.random();
		int y=m_dimImage.height, x=m_dimImage.width;
		int c=2*x+2*y;
		double side=(double)y/c, top=(double)x/c;

		if (t<side){ //left side
			y=(int)(Math.random()*y);
			x=1;
		}else if (t<side+top){ //top
			y=1;
			x=(int)(Math.random()*x);
		}else if (t<2*side+top){ //right side
			y=(int)(Math.random()*y);
			x=x-5;
		}else { //bottom
			x=(int)(Math.random()*x);
			y=y-5;
		}
		return new Point(x,y);
	}

		

	



	//--------------------------------------------------------------------------
	public void start()
	{
		if (m_diffusion == null)
		{
			m_diffusion = new Thread(this);
			((Frap3)applet).theChartRed.start();
			m_diffusion.start();
		}
	}
	
	//--------------------------------------------------------------------------
	public void stop()
	{
		if (m_diffusion != null)
		{
			m_diffusion.stop();
			((Frap3)applet).theChartRed.stop();
			m_diffusion = null;
		}

	}



	//--------------------------------------------------------------------------
	public void run()
	{
		while (true)
		{
			try
			{
				if (m_g != null){
					if (ResetLocation){
						int charge=1;
						for (int i=0; i<NUM_PARTICLE; i++){
							Start.x=(int)(Math.random()*LR.x);
							Start.y=(int)(Math.random()*LR.y);
							p[i].Init(charge,Start,UL,LR);
						}
						ResetLocation=false;
					}

					m_g.setColor(BG);
					m_g.fillRect(0,0,m_dimImage.width,m_dimImage.height);

					//Util.wallPaper(this, m_g, m_bg);

					first=0;
					NumberIn1=0;

					for (int i=0; i<NUM_PARTICLE; i++){
						if (!p[i].Active && (first<density) ){
							first++;
							p[i].NewLocation(NewEntry());
							p[i].m_StdDev=Fast;
							p[i].m_Charge=1;
						}
						else p[i].NewMove();

						if (p[i].Active && m_circ.Inside(p[i].Location())){
							NumberIn1++;
							if (FrapCount>0) p[i].Active=false;
						}
						p[i].DrawParticle(m_g);
					}

					if (FrapCount>0){
						FrapCount = ++FrapCount%6;
						m_circ.DrawFilled(m_g,Color.yellow);
					}else m_circ.Draw(m_g);

					m_r.drawImage(m_image,0,0,null);
					((Frap3)applet).theChartRed.setFillValue(NumberIn1);

					ImageReady=true;
					repaint();
				}
			}
			catch (InterruptedException e)
			{
				// TODO: Place exception-handling code here in case an
				//       InterruptedException is thrown by Thread.sleep(),
				//		 meaning that another thread has interrupted this one
				stop();
			}
		}
	}

	// MOUSE SUPPORT:
	//		The mouseDown() method is called if the mouse button is pressed
	// while the mouse cursor is over the applet's portion of the screen.
	//--------------------------------------------------------------------------
	public boolean mouseDown(Event evt, int x, int y)
	{
		//Start=new Point(x,y);
		//ResetLocation=true;
		//for (int i=0; i<NUM_PARTICLE; i++){
		//	if (m_circ.Inside(p[i].Location()))
		//		p[i].Active=false;
		//}
		//m_circ.DrawFilled(m_g,Color.yellow);
		FrapCount=6;
		return true;
	}

	// MOUSE SUPPORT:
	//		The mouseUp() method is called if the mouse button is released
	// while the mouse cursor is over the applet's portion of the screen.
	//--------------------------------------------------------------------------
	public boolean mouseUp(Event evt, int x, int y)
	{
		return true;
	}

	// MOUSE SUPPORT:
	//		The mouseDrag() method is called if the mouse cursor moves over the
	// applet's portion of the screen while the mouse button is being held down.
	//--------------------------------------------------------------------------
	public boolean mouseDrag(Event evt, int x, int y)
	{
		return true;
	}

	// MOUSE SUPPORT:
	//		The mouseMove() method is called if the mouse cursor moves over the
	// applet's portion of the screen and the mouse button isn't being held down.
	//--------------------------------------------------------------------------
	public boolean mouseMove(Event evt, int x, int y)
	{
		return true;
	}

	// MOUSE SUPPORT:
	//		The mouseEnter() method is called if the mouse cursor enters the
	// applet's portion of the screen.
	//--------------------------------------------------------------------------
	public boolean mouseEnter(Event evt, int x, int y)
	{
		//start();
		return true;
	}

	// MOUSE SUPPORT:
	//		The mouseExit() method is called if the mouse cursor leaves the
	// applet's portion of the screen.
 	//--------------------------------------------------------------------------
	public boolean mouseExit(Event evt, int x, int y)
	{
		//stop();
		return true;
	}


}