/* a client of the aglo library */
 
import java.awt.*;
import java.applet.Applet;
import java.lang.*;
import java.io.*;
import java.util.*;
  

public class Aglo extends Applet implements Runnable {  

	Thread testThread;  
	long start_time;
	int num;
	boolean do_monitor = true;
	boolean do_end_sleep = false;
	boolean enable[] = {true, true, true, true, true, true, true, true};
	double w[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};
	AgloCanvas c; 
	AgloGraph graph; 
	AgloParams parameters = new AgloParams(); 
	AgloMonitor aMonitor = new AgloMonitor(); 
	Label javaglolabel = new Label("JAVAGLO",Label.CENTER); 
	Panel mousePanel = new Panel(); 
	Panel mouse1 = new Panel(); 
	Panel mouse2 = new Panel(); 
	Panel mouse3 = new Panel(); 
	Panel paramPanel = new Panel(); 
	Panel aesthPanel = new Panel(); 
	AgloPanel agloPanel[] = new AgloPanel[12]; 
	String fn; 
	String apNames[] = {	
		"beginning temperature", "ending temperature", "iterations", 
		"monitor delay", "node repulsion", "min edge_length", 
		"centripetal", "node edge repulsion", "min edge intersect", 
		"min edge intersect2", "parent to left", "min level variance"  };   
	String apInitVals[] = {	
		"100.0", "0.001", "1000", "2", "0", "0", 
		"0", "0", "0", "0", "0", "0" }; 
	double apDegVals[] = {	
		5.0, 5.0, 25.0, 0.25, 1.0, 1.0, 
		1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };  
	boolean apBVals[] = {	
		false, false, true, true, false, false,
		false, false, false, false, false, false  }; 


	CheckboxGroup mouseGroup = new CheckboxGroup(); 
	Checkbox chkbox1 = new Checkbox("add point", mouseGroup, true); 
	TextField tf1 = new TextField("x", 3); 
	TextField tf2 = new TextField("y", 3); 
	Checkbox chkbox2 = new Checkbox("add edge", mouseGroup, false); 
	TextField tf3 = new TextField("pt1", 3); 
	TextField tf4 = new TextField("pt2", 3); 
	Checkbox chkbox3 = new Checkbox("move point", mouseGroup, false); 
	TextField tf5 = new TextField("x", 3); 
	TextField tf6 = new TextField("y", 3); 


	// struct font_desc font_desc[] = {
	// { "nr", "node repulsion" },
	// { "mel", "minimize edge length" },
	// { "cp", "centripetal (repulsion from centroid)" },
	// { "ner", "node/edge repulsion" },
	// { "mei", "minimize edge intersections" },
	// { "mei2", "minimize edge intersections v2" },
	// { "pl", "place parent to left of children" },
	// { "mlv", "minimize intralevel variance" },
	// { 0 }
	// };


	public void init()  {  

		int i;  

		// initialize a canvas, put stuffs on it, 
		// draw the windows, wait for input.  

		start_time = System.currentTimeMillis();
		graph = new AgloGraph(aMonitor, 0, 0, true, enable, w) ; 

		c = new AgloCanvas(graph); 

		setLayout(new BorderLayout());
		add("North", javaglolabel);
		add("Center", c);
		add("West", mousePanel);
		add("East", paramPanel);
		add("South", aesthPanel);

		// add components to the panels 
		// mousePanel is an aggregation of 4 flow layout panels
		mousePanel.setLayout(new GridLayout(0,1));

		mousePanel.add(mouse1); 
		mousePanel.add(mouse2); 
		mousePanel.add(mouse3); 

		mouse1.setLayout(new FlowLayout(FlowLayout.LEFT));
		mouse1.add(chkbox1); 
		mouse1.add(tf1); 
		mouse1.add(tf2); 
		mouse2.setLayout(new FlowLayout(FlowLayout.LEFT));
		mouse2.add(chkbox2); 
		mouse2.add(tf3); 
		mouse2.add(tf4); 
		mouse3.setLayout(new FlowLayout(FlowLayout.LEFT));
		mouse3.add(chkbox3); 
		mouse3.add(tf5); 
		mouse3.add(tf6); 

		paramPanel.setLayout(new GridLayout(0,2)); 
		for (i=0; i<4; i++) {  
			paramPanel.add(agloPanel[i] = new AgloPanel(apNames[i], apInitVals[i], apDegVals[i], apBVals[i])); 
		}  

		aesthPanel.setLayout(new GridLayout(0,4)); 
		for (i=4; i<12; i++) {  
			aesthPanel.add(agloPanel[i] = new AgloPanel(apNames[i], apInitVals[i], apDegVals[i], apBVals[i])); 
		}  

	}  


	public void start () { 
		for (int i=0; i<12; i++) {  
			agloPanel[i].start(); 
		}  

		testThread = new Thread(this);
		testThread.start();
		graph.start();	// spin off another thread for the graph layout...    
		c.start();	    
	} 


	public void run () 
	{  
		int i; 

		while (true) { 
			repaint();  
			if (!aMonitor.val()) { 
				// when layout_running == 0... do the following:
				// check agloPanel[i] to see if there are error, illegal inputs...  
				if ((agloPanel[0].getValue() < 0) || (agloPanel[0].getValue() > agloPanel[1].getValue())) { 
					// if there are errors, revert to what was before, update agloPanels...
					agloPanel[0].forceSetValue(parameters.k_begin_temp);  
					agloPanel[1].forceSetValue(parameters.k_end_temp);  
				}  
				else {   
					parameters.k_begin_temp = agloPanel[0].getValue();  
					parameters.k_end_temp = agloPanel[1].getValue();  
				}  
				parameters.k_iterations = (int) agloPanel[2].getValue();  
				parameters.mon_delay = (int) agloPanel[3].getValue();  

				// if not, copy agloPanel[i] into AgloParam and fonts, weights structures
 				for (i=4; i<12; i++) {
					agloPanel[i].repaint();  
					w[i-4] = agloPanel[i].getValue();  
					enable[i-4] = (w[i-4] != 0);  
				}  

				// read file if necessary...   
				// if (fn != null) read_graph(fn,num);   

				// send the graph to layout again, after adjusting parameters,etc....  
				graph.aglo_update(parameters, enable, w);  
				aMonitor.set();  
			}  
			try { 
				testThread.sleep(100); 
			}  catch (InterruptedException e) { 
			}  
		}  

	} 


	public synchronized void update(Graphics g) {
		c.repaint(); 
	} 


	public synchronized boolean handleEvent(Event e) {
		int pt, x, y; 
		double x1, y1;
		int width1 = c.size().width; 
		int height1 = c.size().height;  

		if ((e.target instanceof Checkbox) 
			&& (e.id == Event.ACTION_EVENT)) {  
			if (e.target == chkbox1) 
				c.setMode(0);  
			if (e.target == chkbox2) 
				c.setMode(1);  
			if (e.target == chkbox3) 
				c.setMode(2);  
		} 
		if (e.target instanceof AgloCanvas) {  
			switch (c.getMode()) { 
			case 0:  
				tf1.setText(String.valueOf(c.getX()));
				tf2.setText(String.valueOf(c.getY()));
				break;  
			case 1:  
				tf3.setText(String.valueOf(c.getPoint1()));
				tf4.setText(String.valueOf(c.getPoint2()));
				break;  
			case 2:  
				tf5.setText(String.valueOf(c.getX()));
				tf6.setText(String.valueOf(c.getY()));
				break;  
			}  
		} 
		if ((e.target instanceof TextField) 
			&& (e.id == Event.ACTION_EVENT)) {  
			switch (c.getMode()) { 
			case 0:  
				// add the vertex with the x,y values  
				x = (int) (getTFValue(tf1));  
				y = (int) (getTFValue(tf2));  
				x1 = (double) x / (double) width1;
				y1 = (double) y / (double) height1;
				pt = graph.vertices;
				if (!graph.g_register_vertex(pt+1)) return false;
				graph.StateVector[pt].putValue(0, x1);
				graph.StateVector[pt].putValue(1, y1);
				break;  
			case 1:  
				// add an edge with the two vertices; 
				// check that they are within bound
				x = (int) (getTFValue(tf3));  
				y = (int) (getTFValue(tf4));  
				if ((x<graph.vertices) && (y<graph.vertices)) 
					graph.g_add_edge(x+1, y+1, true); 
				break;  
			case 2:  
				// move a vertex to the x, y location  
				x = (int) (getTFValue(tf5));  
				y = (int) (getTFValue(tf6));  
				x1 = (double) x / (double) width1;
				y1 = (double) y / (double) height1;
				pt = c.getPoint1();
				graph.StateVector[pt].putValue(0, x1);
				graph.StateVector[pt].putValue(1, y1);
				break;  
			}  
		}  
		return false;
	}


	double getTFValue(TextField aTextField) {
		double f;
		try {
			f = Double.valueOf(aTextField.getText()).doubleValue();
		} catch (java.lang.NumberFormatException e) { 
			f = 0.0;  
		}
		return f;  
	} 

	

	public void stop () {  
		cleanup(); 
		for (int i=0; i<12; i++) {  
			agloPanel[i].stop(); 
		}  
		testThread.stop();
	} 


	void cleanup()
	{
		System.out.println("Total time = " + (System.currentTimeMillis() - start_time));
	}
}


class AgloCanvas extends Canvas implements Runnable { 

	int width = 476;
	int height = 476;
	int width1;
	int height1;
	static int LOFFSET = 6;
	static int VOFFSET = 3;
	static int VAREA = 7;
	AgloGraph graph; 
	Thread canvasThread; 
	Image offImage;
	Dimension offDimension;
	Graphics offGraphics;
	Color bgColor = new Color(248,248,164);
	Color borderColor = new Color(248,148,164);
	Color edgeColor = new Color(128,32,176);
	Color vertexColor = new Color(4,156,8);
	Color selectColor = new Color(240,32,64);

	AgloPoint pick = new AgloPoint();
	AgloPoint pick2 = new AgloPoint();
	int pt1, pt2;
	boolean firstSelection = true;  
	int mode = 0;  


	public AgloCanvas (AgloGraph graph) 
	{
		this.resize(width, height);  
		this.graph = graph;  
	} 


	public void output_edge_state(Graphics g)
	{
		AgloEdgeRecord p;

		// print each edge only once (no self-edges) 
		for (int i=0;i<graph.vertices;i++)
			for (int k=0; k<graph.EdgeTable[i].getSize(); k++) { 
				p=graph.EdgeTable[i].getEdge(k);  
				if (i < p.getTail())
				{
					// what happens here is we have normalized points, 
					// we want to normalize with respect to the canvas size,  
					// then we paint an edge on the canvas.    
					g.drawLine(LOFFSET+ (int) (graph.StateVector[i].getValue(0)*width1), 
						LOFFSET+ (int) (graph.StateVector[i].getValue(1)*height1),
						LOFFSET+ (int) (graph.StateVector[p.getTail()].getValue(0)*width1),
						LOFFSET+ (int) (graph.StateVector[p.getTail()].getValue(1)*height1));
				}
			}
	}


	public void run() {
		while (true) {
			repaint(); 
			try {
				canvasThread.sleep(100);
			} catch (InterruptedException e) {
				break;
			}
		}
	}


	public synchronized void update(Graphics g) {
		Dimension d = size();
		int i;
		if ((offImage == null) || (d.width != offDimension.width) || (d.height != offDimension.height)) {
		offImage = createImage(d.width, d.height);
		offDimension = d;
		offGraphics = offImage.getGraphics();
		// offGraphics.setFont(getFont());
		}
	
		offGraphics.setColor(bgColor);
		offGraphics.fillRect(0, 0, d.width, d.height);
		offGraphics.setColor(borderColor);
		offGraphics.drawRect(0, 0, d.width-1, d.height-1);
		offGraphics.drawRect(1, 1, d.width-2, d.height-2);

		// draw the current state of the graph   
		// draw edges first.... 
		offGraphics.setColor(edgeColor);
		output_edge_state(offGraphics);  
		
		// then put nice little vertices 
		offGraphics.setColor(vertexColor);
		for (i=0;i<graph.vertices;i++) {  
			offGraphics.fillOval((int) (VOFFSET + graph.StateVector[i].getValue(0)*width1), (int) (VOFFSET + graph.StateVector[i].getValue(1)*height1), VAREA, VAREA);
		}

		g.drawImage(offImage, 0, 0, null);
	}


	public int getX() 
	{ 
		return (int) (graph.StateVector[pt1].getValue(0)*width1);  
	}  


	public int getY() 
	{ 
		return (int) (graph.StateVector[pt1].getValue(1)*height1);  
	}  


	public int getPoint1() 
	{ 
		return pt1; 
	}  


	public int getPoint2() 
	{ 
		return pt2; 
	}  

	public void setMode(int aMode) 
	{ 
		mode = aMode; 
	}  


	public int getMode() 
	{ 
		return mode; 
	}  


	public synchronized boolean mouseDown(Event evt, int x, int y) 
	{
		double bestdist = 36.0/((double) width1 * (double) height1) ;
		double x1 = (double) (x - VOFFSET) / (double) width1;
		double y1 = (double) (y - VOFFSET) / (double) height1; 

		switch (mode) { 
		case 0:		// add a point 
			firstSelection = true;    
			pt1 = graph.vertices;
			if (!graph.g_register_vertex(pt1+1)) return false; 
			graph.StateVector[pt1].putValue(0, x1);  
			graph.StateVector[pt1].putValue(1, y1);  
			break;  
		case 1:		// add an edge 
			for (int i = 0 ; i < graph.vertices; i++) {
				AgloPoint n = graph.StateVector[i];
				double dist = (n.getValue(0) - x1) * (n.getValue(0) - x1) 
					+ (n.getValue(1) - y1) * (n.getValue(1) - y1);
				if (dist < bestdist) {
					pick = n;
					bestdist = dist;
					if (firstSelection) {   
						pt1 = i;
						firstSelection = false;    
					} else { 
						pt2 = i;
						graph.g_add_edge(pt1+1, pt2+1, true); 
						firstSelection = true;    
					}
				}
			}
			break;  
		case 2:		// move a point 
			firstSelection = true;    
			for (int i = 0 ; i < graph.vertices; i++) {
				AgloPoint n = graph.StateVector[i];
				double dist = (n.getValue(0) - x1) * (n.getValue(0) - x1) 
					+ (n.getValue(1) - y1) * (n.getValue(1) - y1);
				if (dist < bestdist) {
					pick = n;
					bestdist = dist;
					pt1 = i;
					pick.putValue(0, x1);
					pick.putValue(1, y1);
				}
			}
			break;  
		}
		repaint();
		return false;
	}

	
	public synchronized boolean mouseDrag(Event evt, int x, int y) {
		double x1 = (double) x / (double) width1;
		double y1 = (double) y / (double) height1; 
		if (mode == 2) { 
			pick.putValue(0,x1);
			pick.putValue(1,y1);
		}
		repaint();
		return false;
	}

	
	public synchronized boolean mouseUp(Event evt, int x, int y) 
	{
		repaint();
		return false;
	}

	
	public void start() {
		canvasThread = new Thread(this);
		canvasThread.start();
		width1 = size().width - 15; 
		height1 = size().height - 15; 
	}
	
	
	public void stop() {
		canvasThread.stop();
		offImage = null; 
		offGraphics = null; 
	}
}  


class AgloEdgeRecord { 

	int tail;
	boolean forward;  

	public AgloEdgeRecord (int edgeTail, boolean aValue) 
	{
		tail = edgeTail;
		forward = aValue;
	} 

	public int getTail() 
	{ 
		return tail;
	} 

	public boolean getForward() 
	{ 
		return forward;
	}  
}  


class AgloEdgeRecordSet { 

	int size;
	// head is implicit; 
	AgloEdgeRecord EdgeSet [] = null; 

	public AgloEdgeRecordSet() 
	{ 
		size = 0;
	} 

	public int getSize() 
	{ 
		return size;
	} 

	public void addEdge (AgloEdgeRecord anEdge) 
	{  
		boolean sameflag = false; 
		AgloEdgeRecord newSet [] = new AgloEdgeRecord[size+1]; 

		for (int i=0; i<size; i++) {  
			newSet[i] = EdgeSet[i];  
			if (newSet[i].getTail() == anEdge.getTail())
				sameflag = true; 
		} 

		if (!sameflag) { 
			newSet[size] = anEdge;
			EdgeSet = newSet;
			size++;
		} 

	} 

	public AgloEdgeRecord getEdge (int num)  
	{
		return (EdgeSet[num]); 
	}  
}  


/* main aglo library routine */


class AgloGraph implements Runnable {   

	static final int AGLO_MAX_GRAPH_SIZE = 500; 
	int vertices = 0;  
	int edges;  
	int num_aesths = 0;  
	AgloEdgeRecordSet EdgeTable [] = new AgloEdgeRecordSet[AGLO_MAX_GRAPH_SIZE]; 
	AgloPoint StateVector [] = new AgloPoint[AGLO_MAX_GRAPH_SIZE]; 
	AgloParams params = new AgloParams(); 
	AgloMonitor aMonitor = new AgloMonitor(); 
	boolean do_monitor;
	boolean layoutAbort = false;
	boolean font[] = new boolean[8];
	double weight[] = new double[8];
	double t;
	long aglo_graph_sequence; 
	long aglo_state_sequence; 
	Thread layoutThread; 
	long start_time;
	long next_time;
	long startTime;

	// "static" variables" 
		AgloPoint cached_centroid = new AgloPoint();
		long at_state_sequence = 0;
		
		long at_graph_sequence = 0;

	// geometry 600x700-1+1 
	// config =
	// plot both lines and points 
	// offsets 0.1, 0.1, 0.1, 0.1 
	// nokey 
	// plot everything 


	public AgloGraph(AgloMonitor amonitor, long GS, long AS, boolean dm, boolean func_enable[], double w[]) 
	{
		int i; 

		aglo_graph_sequence = GS; 
		aglo_state_sequence = AS; 
		do_monitor = dm; 
		aMonitor = amonitor; 

		for(i=0; i<8; i++) {
			font[i] = func_enable[i]; 
			weight[i] = w[i]; 
			if (font[i]) num_aesths++;  
		} 
		for (i=0; i< AGLO_MAX_GRAPH_SIZE; i++) 
			StateVector[i] = new AgloPoint(); 
		for (i=0; i< AGLO_MAX_GRAPH_SIZE; i++) 
			EdgeTable[i] = new AgloEdgeRecordSet(); 
	} 


	public void start()
	{
		layoutThread = new Thread(this);
		layoutThread.start();
	} 


	public void run()
	{
		startTime = System.currentTimeMillis();
		while (true) {  
			if ((aMonitor.reset()) && vertices >0) find_layout();
			try {
				layoutThread.sleep(100);
			} catch (InterruptedException e) { 
			}
		} 
	} 


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


	public void state_frame_points(AgloPoint min_frame, AgloPoint max_frame)
	{
		// assert(vertices > 0);

		min_frame.assign(StateVector[0]);
		max_frame.assign(StateVector[0]);
		for (int i=0;i<vertices;i++) {
			min_frame.min(StateVector[i]);
			max_frame.max(StateVector[i]);
		}
	}


	public void aglo_update(AgloParams p, boolean func_enable[], double w[]) 
	{ 
		num_aesths = 0;  
		for (int i=0; i<8; i++) {
			font[i] = func_enable[i]; 
			weight[i] = w[i]; 
			if (font[i]) num_aesths++;  
		} 
		if ((p.k_begin_temp != params.k_begin_temp) 
			|| (p.k_end_temp != params.k_end_temp) 
			|| (p.k_iterations != params.k_iterations) 
			|| (p.mon_delay != params.mon_delay)) 
		{   
			layoutAbort = true; 
			params.k_begin_temp = p.k_begin_temp; 
			params.k_end_temp = p.k_end_temp; 
			params.k_iterations = p.k_iterations; 
			params.mon_delay = p.mon_delay; 
		} else
			layoutAbort = false;  

	} 


	public void update_monitor()
	{
		normalize_state(StateVector, StateVector);  
		aMonitor.reset();
	}



	public void zero_state_vector(AgloPoint v[], int size)
	{
		for (int i=0;i<size;i++)
			v[i] = new AgloPoint();
	}

	public void random_placement(double placement_size)
	{
		int i;
		double x, y;

		for (i=0;i<vertices;i++) {
			x = (Math.random() - 0.5) * 2.0 * placement_size;
			y = (Math.random() - 0.5) * 2.0 * placement_size;
			StateVector[i].putValue(0, x); 
			StateVector[i].putValue(1, y); 
		}
	}

// aesthetics...


/* aesthetic 'centripetal' - makes nodes move away from the centroid */

	public void ae_setup_centripetal()
	{
		return;
	}

	public void ae_centripetal(AgloPoint state[], AgloPoint gradient[])
	{
		int i;
		AgloPoint centroid;

		centroid = this.at_centroid(state);

		for (i=0;i<vertices;i++)
		{
			AgloPoint delta = new AgloPoint();
			double mag2;
			AgloPoint force_delta = new AgloPoint();
		
			delta.sub(state[i], centroid);
			mag2 = delta.mag2();
			mag2 = Math.max(mag2, 1e-8); /* avoid div by 0 */
		
			force_delta.scalar_mult(1/mag2, delta);
		
			gradient[i].add(gradient[i], force_delta);
		}
	}


/* aesthetic 'min edge intersect' - makes crossed edges uncross */

	public void ae_setup_min_edge_intersect()
	{
		return;
	}

	public int ccw(double x0, double y0, double x1, double y1, double x2, double y2)
	{
		double dx1, dx2, dy1, dy2;
		dx1 = x1 - x0; dy1 = y1 - y0;
		dx2 = x2 - x0; dy2 = y2 - y0;
		if (dx1*dy2 > dy1*dx2) return +1;
		if (dx1*dy2 < dy1*dx2) return -1;
		if ((dx1*dx2 < 0) || (dy1*dy2 < 0)) return -1;
		if ((dx1*dx1+dy1*dy1) < (dx2*dx2+dy2*dy2)) return +1;
		return 0;
	}

	public boolean intersect(double x11, double y11, double x12, double y12, /* line 1 */
		  double x21, double y21, double x22, double y22) /* line 2 */
	{
		return ((ccw(x11, y11, x12, y12, x21, y21)
			 	*ccw(x11, y11, x12, y12, x22, y22)) <= 0)
			&& ((ccw(x21, y21, x22, y22, x11, y11)
			 	*ccw(x21, y21, x22, y22, x12, y12)) <= 0);
	}

	public void ae_intersection1(AgloPoint state[], AgloPoint gradient[], int p11, int p12, int p21, int p22) 
	{
		if (intersect(state[p11].getValue(0), state[p11].getValue(1), state[p12].getValue(0), state[p12].getValue(1),
				  state[p21].getValue(0), state[p21].getValue(1), state[p22].getValue(0), state[p22].getValue(1)))
		{
			AgloPoint mid1 = new AgloPoint();
			AgloPoint mid2 = new AgloPoint();
			AgloPoint delta = new AgloPoint();
			double mag;
			AgloPoint force_delta = new AgloPoint();
		
			mid1.midpoint(state[p11], state[p12]);
			mid2.midpoint(state[p21], state[p22]);
			delta.sub(mid2, mid1);
			mag = delta.mag();
			mag = Math.max(mag, 1e-8); /* avoid div by 0 */
			force_delta.scalar_mult(1/mag, delta);

			gradient[p11].dec(force_delta);
			gradient[p12].dec(force_delta);
			gradient[p21].inc(force_delta);
			gradient[p22].inc(force_delta);
		}
	}

	public void ae_min_edge_intersect1(AgloPoint state[], AgloPoint gradient[])
	{
		int i, j, k, l;
		AgloEdgeRecord p, q;

		/* this doesn't make any sense except in 2D */
		// assert(AGLO_SPACE_ARITY == 2);

		/* all 4 endpoints are distinct */
		/* i p */
		/* i j q */
		for (i=0;i<vertices;i++)
			for (k=0; k<EdgeTable[i].getSize(); k++) {  
				p=EdgeTable[i].getEdge(k);  
				if (i < p.getTail())
					for (j=i+1;j<vertices;j++)
						if (j != p.getTail())
							for (l=0; l<EdgeTable[j].getSize(); l++) {  
								q=EdgeTable[j].getEdge(l);  
								if (j < q.getTail() && p.getTail() != q.getTail())
									ae_intersection1(state, gradient, i, p.getTail(), j, q.getTail());
							}
			}
	}


/* aesthetic 'min edge intersect' - makes crossed edges uncross (stronger version) */


	public void ae_setup_min_edge_intersect2()
	{
		return;
	}

	public void ae_intersection2(AgloPoint state[], AgloPoint gradient[], int p11, int p12, int p21, int p22) 
	{
		if (intersect(state[p11].getValue(0), state[p11].getValue(1), state[p12].getValue(0), state[p12].getValue(1),
				  state[p21].getValue(0), state[p21].getValue(1), state[p22].getValue(0), state[p22].getValue(1)))
		{
			AgloPoint mid1 = new AgloPoint(); 
			AgloPoint mid2 = new AgloPoint();
			AgloPoint delta = new AgloPoint();
			double mag;
		
			mid1.midpoint(state[p11], state[p12]);
			mid2.midpoint(state[p21], state[p22]);
			delta.sub(mid2, mid1);
			mag = delta.mag();
			mag = Math.max(mag, 1e-8); /* avoid div by 0 */

			gradient[p11].dec(delta);
			gradient[p12].dec(delta);
			gradient[p21].inc(delta);
			gradient[p22].inc(delta);
		}
	}

	public void ae_min_edge_intersect2(AgloPoint state[], AgloPoint gradient[])
	{
		int i, j, k, l;
		AgloEdgeRecord p, q;

		/* this doesn't make any sense except in 2D */
		// assert(AGLO_SPACE_ARITY == 2);

		/* all 4 endpoints are distinct */
		/* i p */
		/* i j q */ 
		for (i=0;i<vertices;i++)
			for (k=0; k<EdgeTable[i].getSize(); k++) {  
				p=EdgeTable[i].getEdge(k);  
				if (i < p.getTail())
					for (j=i+1;j<vertices;j++)
						if (j != p.getTail())
							for (l=0; l<EdgeTable[j].getSize(); l++) {  
								q=EdgeTable[j].getEdge(l);  
								if (j < q.getTail() && p.getTail() != q.getTail())
									ae_intersection2(state, gradient, i, p.getTail(), j, q.getTail());
							}
			}
	}


/* aesthetic 'minimize edge length' - makes edges shrink in length */


	public void ae_setup_min_edge_length()
	{
		return;
	}

	public void ae_min_edge_length(AgloPoint state[], AgloPoint gradient[])
	{
		int i, j, k;
		AgloEdgeRecord p;

		for (i=0;i<vertices;i++)
			for (k=0; k<EdgeTable[i].getSize(); k++) {  
				p=EdgeTable[i].getEdge(k);  
				if (i < (j=p.getTail()))
				{
					AgloPoint delta = new AgloPoint();
					double mag;
					AgloPoint force_delta = new AgloPoint();

					delta.sub(state[i], state[j]);
					mag = delta.mag();
					mag = Math.max(mag, 1e-8); /* avoid div by 0 */

					force_delta.scalar_mult(mag, delta);

					gradient[i].dec(force_delta);
					gradient[j].inc(force_delta);
				}
			}
	}


/* aesthetic 'min level variance' - put nodes on same level on same X coord */


	public void ae_setup_min_level_variance()
	{
		at_setup_node_level();
	}

	public void ae_min_level_variance(AgloPoint state[], AgloPoint gradient[])
	{
		int i, l;
		int AXIS = 0;
		double level_distance_sum[] = new double[AGLO_MAX_GRAPH_SIZE]; /* sigma X */
		for (i=0; i<AGLO_MAX_GRAPH_SIZE; i++)
			level_distance_sum[i] = 0; 


		for (l=0;at_level_nodes_size[l]>0;l++)
		{
			for (i=0;i<at_level_nodes_size[l];i++)
				level_distance_sum[l] += state[at_level_nodes[l][i]].getValue(AXIS);
			level_distance_sum[l] /= i;
		}

		for (l=0;at_level_nodes_size[l]>0;l++)
			for (i=0;i<at_level_nodes_size[l];i++)
			{
				double delta = level_distance_sum[l] - state[at_level_nodes[l][i]].getValue(AXIS);
				double mag = Math.abs(delta);
				if (mag > 0.0)
				{					/* check this */
					double force_delta = mag * mag * delta;
					gradient[at_level_nodes[l][i]].putValue(AXIS, 
						gradient[at_level_nodes[l][i]].getValue(AXIS) + force_delta);
				}
			}
	}


/* aesthetic 'node edge repulsion' - makes node and edges spread apart */


	public void ae_setup_node_edge_repulsion()
	{
		return;
	}

	public void ae_line_line_intersection(double a1, double b1, double c1, double a2, double b2, double c2, AgloPoint i)
	{
		/* this is really hideous, but good enough for now, I hope */

		// assert(a1 != 0.0 || b1 != 0.0);
		// assert(a2 != 0.0 || b2 != 0.0);

		if (a1 == 0.0)
			i.putValue(1, -c1 / b1);
		else if (a2 == 0.0)
			i.putValue(1, -c2 / b2);
		else
		{
			double piv = -a2 / a1;
			double b = piv * b1 + b2;
			double c = piv * c1 + c2;
			i.putValue(1, -c / b);
		}
		if (b1 == 0.0)
			i.putValue(0, -c1 / a1);
		else if (b2 == 0.0)
			i.putValue(0, -c2 / a2);
		else if (a1 == 0.0)
		{
			// assert(a2 != 0.0);
			i.putValue(0, -(b2 * i.getValue(1) + c2) / a2);
		}
		else
		{
			i.putValue(0, -(b1 * i.getValue(1) + c1) / a1);
		}
	}

	public void ae_line_point_vector(AgloPoint e1, AgloPoint e2, AgloPoint p, AgloPoint v)
	{
		double a, b, c, a1, b1, c1;
		AgloPoint e1e2 = new AgloPoint(); 
		AgloPoint i = new AgloPoint();

		/* TBF 3D not implemented */
		// assert(AGLO_SPACE_ARITY == 2);

		a = e2.getValue(1) - e1.getValue(1);
		b = e1.getValue(0) - e2.getValue(0);
		c = e1.getValue(1) * e2.getValue(0) - e2.getValue(1) * e1.getValue(0);
		e1e2.sub(e2, e1);
		a1 = e1e2.getValue(0);
		b1 = e1e2.getValue(1);
		c1 = -(e1e2.getValue(1) * p.getValue(1) + e1e2.getValue(0) * p.getValue(0));
		ae_line_line_intersection(a, b, c, a1, b1, c1, i);
		v.sub(p, i);
	}
	
	public void ae_point_linesegment_distance_2(AgloPoint state[], AgloPoint gradient[], int pn, int e1n, int e2n)
	{
		AgloPoint e1p = new AgloPoint(); 
		AgloPoint e2p = new AgloPoint(); 
		AgloPoint e1e2 = new AgloPoint(); 
		AgloPoint e2e1 = new AgloPoint();
		double dp_e2e1p, dp_e1e2p;

		e1p.sub(state[pn], state[e1n]);
		e2p.sub(state[pn], state[e2n]);
		e1e2.sub(state[e2n], state[e1n]);
		e2e1.scalar_mult(-1, e1e2);
		dp_e2e1p = e1p.dot_product(e1e2);
		dp_e1e2p = e2p.dot_product(e2e1);

		if (dp_e2e1p >= 0)			/* acute */
			if (dp_e1e2p >= 0)		/* acute */
			{
				AgloPoint delta = new AgloPoint();
				double mag2;
				AgloPoint force_delta = new AgloPoint();
				AgloPoint half_force_delta = new AgloPoint();
			
				ae_line_point_vector(state[e1n], state[e2n], state[pn], delta);
				mag2 = delta.mag2();
				mag2 = Math.max(mag2, 1e-8); /* avoid div by 0 */

				force_delta.scalar_mult(1/mag2, delta);
				half_force_delta.scalar_mult(0.5, force_delta);

				gradient[pn].inc(force_delta);
				gradient[e1n].dec(half_force_delta);
				gradient[e2n].dec(half_force_delta);
			}
		/* really should handle the case when not both acute TBF */
	}

	public void ae_node_edge_repulsion(AgloPoint state[], AgloPoint gradient[])
	{
		int i, j, k;
		AgloEdgeRecord p;

		/* i < p */
		/* j != i; j != p */
		for (j=0;j<vertices;j++)
			for (i=0;i<vertices;i++)
				if (i != j)
					for (k=0; k<EdgeTable[i].getSize(); k++) {  
						p=EdgeTable[i].getEdge(k);  
						if (i < p.getTail() && j != p.getTail())
							ae_point_linesegment_distance_2(state, gradient, j, i, p.getTail());
					}
	}


/* aesthetic 'node repulsion' - makes nodes spread apart */


	public void ae_setup_node_repulsion()
	{
		return;
	}

	public void ae_node_repulsion(AgloPoint state[], AgloPoint gradient[])
	{
		int i, j;

		for (i=1;i<vertices;i++)
			for (j=0;j<i;j++)
			{
				AgloPoint delta = new AgloPoint();
				double mag2;
				AgloPoint force_delta = new AgloPoint();

				delta.sub(state[i], state[j]);
				mag2 = delta.mag2();
				mag2 = Math.max(mag2, 1e-8); /* avoid div by 0 */

				force_delta.scalar_mult(1/mag2, delta);

				gradient[i].add(gradient[i], force_delta);
				gradient[j].sub(gradient[j], force_delta);
			}
	}


/* aesthetic 'parent left' - put parent to left of child */


/* TBF - this needs to be set by the client */

	public void ae_setup_parent_left() {
		return;
	}

	public void ae_parent_left(AgloPoint state[], AgloPoint gradient[])
	{
		int i, k;
	int AXIS = 0;
	double K_PARENT_LEFT_BUFFER = 5.0;
		AgloEdgeRecord p;
		double a, b;


		for (i=0;i<vertices;i++)
			for (k=0; k<EdgeTable[i].getSize(); k++) {  
				p=EdgeTable[i].getEdge(k);  
				if (p.getForward())
					if ((a = state[i].getValue(AXIS) + K_PARENT_LEFT_BUFFER)
						>= (b = state[p.getTail()].getValue(AXIS))) 
					{
						double mag = (a-b) * (a - b);
						gradient[i].putValue(AXIS, gradient[i].getValue(AXIS) + (-mag));
						gradient[p.getTail()].putValue(AXIS, gradient[p.getTail()].getValue(AXIS) + mag);
					}
			}
	}


/* attribute 'centroid' - centroid of current state */

	public AgloPoint at_centroid(AgloPoint state[])
	{
		if ( (at_state_sequence < aglo_state_sequence || aglo_state_sequence == 0) )
		{
			at_state_sequence = aglo_state_sequence;
			int i;

			cached_centroid.zero();
			for (i=0;i<vertices;i++)
			cached_centroid.add(cached_centroid, state[i]);
			cached_centroid.scalar_mult(1.0/vertices, cached_centroid);
		}

		return (cached_centroid);
	}


/* attribute 'node level' - level of node (from root) */

	int at_node_level[] = new int [AGLO_MAX_GRAPH_SIZE];
	int at_level_nodes[][] = new int [AGLO_MAX_GRAPH_SIZE][AGLO_MAX_GRAPH_SIZE];
	int at_level_nodes_size[] = new int [AGLO_MAX_GRAPH_SIZE];

	boolean at_node_level_assigned[] = new boolean[AGLO_MAX_GRAPH_SIZE]; /* gvlevel[i] valid? */

	public int at_node_level_tree(int v)
	{
		AgloEdgeRecord p;
		int kid_level=1;
	
		if (at_node_level_assigned[v])
			return at_node_level[v];

		at_node_level_assigned[v] = true;
		at_node_level[v] = 0;

		for (int i=0; i<EdgeTable[v].getSize(); i++) {  
			p=EdgeTable[v].getEdge(i);  
			if (p.getForward())
			{
				int k = at_node_level_tree(p.getTail());
				if (k < kid_level)
					kid_level = k;
			}
		}
			
		return at_node_level[v] = kid_level - 1;
	}

	public void at_contract_node_level_tree()
	{
		int change;

		for (change=1;change>0;)
		{
			int i;
			AgloEdgeRecord p;

			change=0;
			for (i=0;i<vertices;i++)
			{
				int max_p_level = -65536;
				for (int k=0; k<EdgeTable[i].getSize(); k++) {  
					p=EdgeTable[i].getEdge(k);  
					if (!p.getForward())
						if (max_p_level < at_node_level[p.getTail()])
							max_p_level = at_node_level[p.getTail()];
				}
				if (max_p_level == -65536)
					continue;
				max_p_level++;
				if (max_p_level < at_node_level[i])
				{
					at_node_level[i] = max_p_level;
					change=1;
				}
			}
		}
	}

	public void at_make_node_level_lists(int level)
	{
		int list=0;
		int vcount=0;			/* doublecheck */
		int i;

		for (i=0;i<vertices;i++)
			at_node_level[i] -= level;

		level = 0;

		while (true) 
		{
			int tvcount = vcount;
		
			for (i=0;i<vertices;i++)
				if (at_node_level[i] == level)
				{
					at_level_nodes[list][at_level_nodes_size[list]++] = i;
					vcount++;
				}
			if (vcount == vertices)
				return;
			// assert(vcount != tvcount);
			level++; 
			list++;  
		}
	}

	public void at_calculate_node_level()
	{
		int i;
		int lev;
		int min_level = 65536;

		/* initial assignement */
		for (i=0;i<vertices;i++)
		{
			lev = at_node_level_tree(i);
			if (lev < min_level)
				min_level = lev;
		}

		/* contraction */
		at_contract_node_level_tree();

		at_make_node_level_lists(min_level);
	}

	public void at_setup_node_level()
	{
		if ( (at_graph_sequence < aglo_graph_sequence || aglo_graph_sequence == 0) ) {
			at_graph_sequence = aglo_graph_sequence;
			at_calculate_node_level();
		}
	}


	public void calculate_aesth_forces(AgloPoint gradient[])
	{
		int i, j;
	
		zero_state_vector(gradient, vertices);

		j=0; 
		while (j < 8)
		{
			if (font[j]) { 
				AgloPoint a_gradient[] = new AgloPoint[vertices];
				zero_state_vector(a_gradient, vertices);
				switch (j) {
			
				case 0:	
					ae_node_repulsion(StateVector, a_gradient); 	
					break; 
				case 1:	
					ae_min_edge_length(StateVector, a_gradient); 	
					break; 
				case 2:
					ae_centripetal(StateVector, a_gradient); 	
					break; 
				case 3:	
					ae_node_edge_repulsion(StateVector, a_gradient); 	
					break; 
				case 4:	
					ae_min_edge_intersect1(StateVector, a_gradient); 	
					break; 
				case 5:	
					ae_min_edge_intersect2(StateVector, a_gradient); 	
					break; 
				case 6:
					ae_parent_left(StateVector, a_gradient); 	
					break; 
				case 7:	
					ae_min_level_variance(StateVector, a_gradient); 	
					break; 
				} 		
			
				for (i=0;i<vertices;i++) {  
					a_gradient[i].scalar_mult(weight[j], a_gradient[i]);
					gradient[i].inc(a_gradient[i]);
				}
			}

			j++; 
		}
	}

	public void limit_displacement(double t, AgloPoint gradient[], int size)
	{
		int i;
		double sum_sqr = 0;
		double mag;

		for (i=0;i<size;i++)
			sum_sqr += Math.pow(gradient[i].mag2(),2);
		mag = Math.sqrt(sum_sqr);
		if (mag > t)
		{
			mag = t / mag;
			for (i=0;i<size;i++)
				gradient[i].scalar_mult(mag, gradient[i]);
		}
	}

	public void make_move(AgloPoint state[], AgloPoint gradient[], int size)
	{
		for (int i=0;i<size;i++)
			state[i].inc(gradient[i]);
	}

	public void jitter(AgloPoint state[], int size)
	{
		long l = (long) (Math.random() * 230.9);
		int i = (int) l % size;
		int j = (int) l % 2;
		int sign = -1 + 2 * ((int) l % 2); /* -1 or 1 */
		double x = 0.0;

		x = sign * 0.00001;

		state[i].putValue(j, state[i].getValue(j) + x);
	}

	public void do_aesth_setup()
	{
		int j=0; 
		while (j < 8)
		{
			if (font[j]) 
			switch (j) {
			
			case 0:	ae_setup_node_repulsion(); 	
				break; 
			case 1:	ae_setup_min_edge_length(); 	
				break; 
			case 2:	ae_setup_centripetal(); 	
				break; 
			case 3:	ae_setup_node_edge_repulsion(); 	
				break; 
			case 4:	ae_setup_min_edge_intersect(); 	
				break; 
			case 5:	ae_setup_min_edge_intersect2(); 	
				break; 
			case 6:	ae_setup_parent_left(); 	
				break; 
			case 7:	ae_setup_min_level_variance(); 	
				break; 
			} 		
			
			j++;
		}
	}


/* ---------------------------------------------------------------------- */


	public void find_layout()
	{
		double k_lambda;
		long i;
		AgloPoint gradient[] = new AgloPoint[AGLO_MAX_GRAPH_SIZE];

		aglo_graph_sequence++;

		if (vertices > 20)
			random_placement(1.0);

		// assert(p.k_begin_temp > p.k_end_temp);
		// assert(p.k_end_temp > 0);
		// assert(p.k_iterations > 0);
	
		k_lambda = Math.pow(params.k_begin_temp / params.k_end_temp, 1.0 / params.k_iterations);
		t = params.k_begin_temp;

		do_aesth_setup();

		if (do_monitor)
		{
			start_time = System.currentTimeMillis();
			next_time = start_time + 20*num_aesths*params.mon_delay;
			update_monitor();
		}
		for (i=1;i<=params.k_iterations;i++)
		{
			if (layoutAbort) break;  
			aglo_state_sequence++;
			calculate_aesth_forces(gradient);
			limit_displacement(t, gradient, vertices);
			make_move(StateVector, gradient, vertices);
			jitter(StateVector, vertices);
			t = t / k_lambda;
			if (do_monitor)
				if (System.currentTimeMillis() >= next_time)
				{
					next_time += 20*num_aesths*params.mon_delay;
					update_monitor();
				}
			if (layoutAbort) break;  
		}

		if (do_monitor)
			update_monitor();
	}

	void normalize_state(AgloPoint norm_state[], AgloPoint state[]) 
	{
		/* possibly norm_state == state */

		AgloPoint min_frame = new AgloPoint(); 
		AgloPoint max_frame = new AgloPoint();
		AgloPoint min_iso_frame = new AgloPoint();
		AgloPoint max_iso_frame = new AgloPoint();
		double iso_frame_size;
		int i;

		state_frame_points(min_frame, max_frame);
		min_iso_frame.iso_frame(min_iso_frame, max_iso_frame, min_frame, max_frame);
		iso_frame_size = max_iso_frame.diffx(min_iso_frame);
		for (i=0;i<vertices;i++)
		{
			norm_state[i].sub(state[i], min_iso_frame);
			if (iso_frame_size > 0)
				norm_state[i].scalar_mult(1/iso_frame_size, norm_state[i]);
		}
	}



	/* read graphs and write states, etc. */

	public boolean g_register_vertex(int v)
	{

		if (v == 0)
		{
			// System.err.println("0 is invalid vertex");
			return false;
		}
		vertices = Math.max(vertices, v);
		if (vertices > AGLO_MAX_GRAPH_SIZE) 
		{  
			// System.err.println("vertex allocation exceeded");
			return false;
		}
		return true;
	}

	public boolean g_add_edge(int v1, int v2, boolean forward) 
	{
		if (v1 == v2) return true;
		else if (v1 < v2) { 
			AgloEdgeRecord gp = new AgloEdgeRecord(--v2,forward);
			EdgeTable[--v1].addEdge(gp);
			return true;
		}
		else { 
			AgloEdgeRecord gp = new AgloEdgeRecord(--v1,forward);
			EdgeTable[--v2].addEdge(gp);
			return true;
		}
	}


}


class AgloMonitor { 
	private boolean layout_running = false; 


	public synchronized boolean val() {
		return layout_running; 
	}  

	public synchronized boolean set() {
		while (layout_running) {  
			try {
				wait();
			} catch (InterruptedException e) { 
			}
		} 
		layout_running = true;
		notify(); 
		return true; 
	}  


	public synchronized boolean reset() {
		while (!layout_running) {  
			try {
				wait();
			} catch (InterruptedException e) { 
			}
		} 
		layout_running = false;
		notify(); 
		return true; 
	}  
}


class AgloPanel extends Panel implements Runnable {

	AgloPanelCanvas aCanvas;
	TextField aTextField; 
	double currentValue; 
	Label aLabel; 
	double degValue;	// this is how much each degree on the knob represents  
	boolean intConstraint; 
	Thread panelThread; 
	Panel aPanel = new Panel();  
	Panel aPanel2 = new Panel();  


	AgloPanel(String somelabel, String somestring, double degVal, boolean aVal) {
		degValue = degVal; 
		intConstraint = aVal;	// if this is set, the value has to be unsigned int  
		this.setLayout(new FlowLayout());
		this.add(aPanel2);

		aPanel2.setLayout(new GridLayout(0,1));
		currentValue = Double.valueOf(somestring).doubleValue();
		aCanvas = new AgloPanelCanvas(63,currentValue/degVal);
		aPanel2.add(aCanvas); 
		aPanel2.add(aPanel); 

		aPanel.setLayout(new GridLayout(0,1));
		aPanel.add(aLabel = new Label(somelabel,Label.CENTER)); 
		aPanel.add(aTextField = new TextField(somestring,18)); 

	}


	public void start() {
		panelThread = new Thread(this); 
		panelThread.start(); 
	}


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

	public double getValue() {
		return (currentValue);  
	} 


	public void forceSetValue(double aVal) {
		currentValue = aVal;  
	} 


	public void run () {
		while (true) {  
			aCanvas.repaint();  
			try { 
				panelThread.sleep(100);  
			} catch(InterruptedException e) {  
			} 
		} 
	} 


	public synchronized boolean handleEvent(Event e) {
		if (e.target instanceof Canvas) {
			currentValue = (double) (aCanvas.getAngle() * degValue);  
			if (!intConstraint) 
				aTextField.setText(String.valueOf(currentValue));
			else {  
				if (currentValue < 0) 
					currentValue = 0.0;
				aCanvas.setAngle(currentValue/degValue); 
				aTextField.setText(String.valueOf((int) currentValue));
			} 
			aCanvas.repaint(); 
		} else if ((e.target instanceof TextField)
			&& (e.id == Event.ACTION_EVENT)) {
			currentValue = getTFValue();  
			if (!intConstraint) 
				aTextField.setText(String.valueOf(currentValue));
			else {  
				if (currentValue < 0) 
					currentValue = 0.0;
				aTextField.setText(String.valueOf((int) currentValue));
			}  
			aCanvas.setAngle(currentValue/degValue); 
			aCanvas.repaint(); 
		}
		return false;
	}


	double getTFValue() {
		double f;
		try {
			f = Double.valueOf(aTextField.getText()).doubleValue();
		} catch (java.lang.NumberFormatException e) { 
			f = 0.0;  
		}
		return f;  
	} 
}

	
class AgloPanelCanvas extends Canvas {

	double angle;
	int center;
	int diameter;
	double size;
	int xinit, yinit;
	boolean onknob = false; 
	final Color indicatorColor = new Color(23, 208, 243);
	final Color notchColor = new Color(205, 105, 201);
	Color arcColors[] = new Color[3];


	public AgloPanelCanvas(int side, double initAngle) 
	{
		this.resize((side+5), side);
		diameter = side;
		size = side*side/4.0;
		center = side/2;
		angle = initAngle; 
		arcColors[0] = new Color(0, 103, 194);
		arcColors[1] = new Color(12, 73, 200);
		arcColors[2] = new Color(2, 0, 135);
	}


	public void setAngle(double aValue) 
	{ 
		angle = aValue;
	}  


	public double getAngle() 
	{ 
		return angle;
	}  


	public void update(Graphics g) 
	{
		// draw the notch for 0 position...  
		g.setColor(notchColor); 
		g.drawLine(2*center,center,2*center+4,center); 

		// draw the circle...  
		for (int i=0; i<12; i++) {  
			g.setColor(arcColors[i%3]); 
			g.fillArc(0,0,diameter,diameter,((int) angle)+30*i,30); 
		}  

		//draw the dot (the indicator)...   
		g.setColor(indicatorColor); 
		g.fillOval(-4 + center + (int) (23.0*Math.cos(angle * Math.PI / 180.0)), 
			   -4 + center + (int) (-23.0*Math.sin(angle * Math.PI / 180.0)), 9, 9); 
	}
	
	
	public void paint(Graphics g) 
	{
		g.setColor(arcColors[2]); 
		g.fillOval(0, 0, diameter, diameter); 
		update(g); 	
	}
	
	
	public synchronized boolean mouseDown(Event evt, int x, int y) 
	{
		if (((x-center)*(x-center) + (y-center)*(y-center)) < size) {  
			xinit = x-center;
			yinit = center-y;
			onknob = true;
		} else 
			onknob = false; 
		return false;
	}
	
	public synchronized boolean mouseDrag(Event evt, int x, int y) 
	{
		double theta1, theta2; 
		double deltatheta; 
		int x1, y1; 

		x1 = x-center;
		y1 = center-y;
		if (onknob) {  
			theta1 = Math.atan((double)yinit/(double)xinit); 
			if (xinit < 0) theta1 += Math.PI; 
			theta2 = Math.atan((double)y1/(double)x1); 
			if (x1 < 0) theta2 += Math.PI; 
			if ((theta1 > Math.PI) && (theta2 < 0))  
				theta1 -= 2*Math.PI; 
			if ((theta2 > Math.PI) && (theta1 < 0))  
				theta1 += 2*Math.PI; 

			deltatheta = theta2 - theta1; 
			angle += deltatheta * 180.0 / Math.PI; 
			xinit = x-center; 
			yinit = center-y; 
		} 

		repaint();
		return false;
	}
	
	

	public synchronized boolean mouseUp(Event evt, int x, int y) 
	{
		onknob = false; 
		repaint();
		return false;
	}
}
	

class AgloParams {  

	double k_begin_temp; 
	double k_end_temp; 
	int k_iterations; 
	int mon_delay;  

	public AgloParams() 
	{ 
		k_begin_temp = 100.0; 
		k_end_temp = 0.001; 
		k_iterations = 1000; 
		mon_delay = 2;  

	} 
}  

/* point manipulation routines */

class AgloPoint {  

	static final int AGLO_SPACE_ARITY = 2; 
	double point[] = new double[2]; 

	public AgloPoint ()
	{
		point[0] = 0.0;
		point[1] = 0.0;
	}

	public AgloPoint (double x, double y)
	{
		point[0] = x;
		point[1] = y;
	}

	public void add(AgloPoint arg1, AgloPoint arg2)
	{
		for(int i=0;i<AGLO_SPACE_ARITY;i++)
			point[i] = arg1.point[i] + arg2.point[i];
	}

	public void sub(AgloPoint arg1, AgloPoint arg2)
	{
		for(int i=0;i<AGLO_SPACE_ARITY;i++)
			point[i] = arg1.point[i] - arg2.point[i];
	}

	public void inc(AgloPoint arg)
	{
		for(int i=0;i<AGLO_SPACE_ARITY;i++)
			point[i] += arg.point[i];
	}

	public void dec(AgloPoint arg)
	{
		for(int i=0;i<AGLO_SPACE_ARITY;i++)
			point[i] -= arg.point[i];
	}

	public double mag2()
	{
		double result = 0;
		for(int i=0;i<AGLO_SPACE_ARITY;i++)
			result += point[i] * point[i];

		return (result);
	}

	public double mag()
	{
		double result = Math.sqrt(this.mag2());
		return (result);
	}

	public void midpoint(AgloPoint arg1, AgloPoint arg2)
	{
		for(int i=0;i<AGLO_SPACE_ARITY;i++)
			point[i] = (arg1.point[i] + arg2.point[i]) / 2;
	}

	public void iso_frame(AgloPoint min_iso_frame, AgloPoint max_iso_frame, AgloPoint min_frame, AgloPoint max_frame)
	{
		AgloPoint frame_sides = new AgloPoint(); 
		AgloPoint frame_center = new AgloPoint(); 
		AgloPoint iso_radius = new AgloPoint();
		double max_side;
		int i;


		frame_sides.sub(max_frame, min_frame);
		frame_center.midpoint(min_frame, max_frame);
		max_side = frame_sides.point[0];
		for(i=1;i<AGLO_SPACE_ARITY;i++)
			max_side = Math.max(max_side, frame_sides.point[i]);
		for(i=0;i<AGLO_SPACE_ARITY;i++)
			iso_radius.point[i] = max_side/2;
		min_iso_frame.sub(frame_center, iso_radius);
		max_iso_frame.add(frame_center, iso_radius);
	}

	public void scalar_mult(double scalar_arg, AgloPoint arg)
	{
		for(int i=0;i<AGLO_SPACE_ARITY;i++)
			point[i] = scalar_arg * arg.point[i];
	}

	public double dot_product(AgloPoint arg)
	{
		double result = 0;
		for(int i=0;i<AGLO_SPACE_ARITY;i++)
			result += point[i] * arg.point[i];

		return (result);
	}

	public void assign(AgloPoint arg)
	{
		for(int i=0;i<AGLO_SPACE_ARITY;i++)
			point[i] = arg.point[i];
	}


	public void zero()
	{
		for(int i=0;i<AGLO_SPACE_ARITY;i++)
			point[i] = 0;
	}

	public void min(AgloPoint arg)
	{

		for(int i=0;i<AGLO_SPACE_ARITY;i++)
			point[i] = Math.min(point[i], arg.point[i]);
	}

	public void max(AgloPoint arg)
	{

		for(int i=0;i<AGLO_SPACE_ARITY;i++)
			point[i] = Math.max(point[i], arg.point[i]);
	}

	public double diffx(AgloPoint arg)
	{
		return (point[0] - arg.point[0]);
	}

	public double getValue(int num)
	{
		return (point[num]);
	}

	public void putValue(int num, double aValue)
	{
		point[num] = aValue;
	}
}