/*
 * Created on 8.2.2005
 * 
 */
package viewer;

import java.awt.*;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.util.ArrayList;

/**
 * @author Matti Paalanen
 * 
 * DrawCanvas represents the drawable surface into which all the information is also 
 * painted.
 * 
 * There are two distinct DrawCanvases used in the Applet. The one the user can draw upon and trigger animations with the buttons
 * and the second one, that is used to visualize the function - the one into which the points are mapped via the defined function.
 * First one is set as drawable, second one not.
 * 
 */
public class DrawCanvas extends Canvas implements MouseMotionListener, MouseListener {
	
	public boolean sweepMode;
	public boolean fillMode;
	public boolean gridMode;
	private int sweepLine;
	private int lineMode;
	
	public boolean connectLines = true;
	
	private ViewerApplet owner;
	
	private Image buffer;				//for double-buffering (efficient paint-operations)
	private Graphics buf;				//for double-buffering
			
	public ArrayList objects = new ArrayList();
	
	public double prevX;
	public double prevY;
	
	public boolean drawable;
	
	public static AlphaComposite alpha = makeComposite(0.3f);
	
	public DrawCanvas(ViewerApplet owner, boolean drawable) {
		super();		
		this.owner = owner;
		this.drawable = drawable;
		
		addMouseMotionListener(this);
		addMouseListener(this);
	}
	
	private static AlphaComposite makeComposite(float alpha) {
	    int type = AlphaComposite.SRC_OVER;
	    return(AlphaComposite.getInstance(type, alpha));
	}
	
	public void paint(Graphics g) {
		
		int h = getHeight();
		int w = getWidth();
				
		int[] areaSize = {w, h};
		double[] limits = owner.getSourceLimits(this);
		//Initialize double-buffering. Inside paint operation for insurance.
		
		if(buffer==null||(buffer.getWidth(this)<w||buffer.getHeight(this)<h)) {			
			buffer = createImage(w,h);
			buf = buffer.getGraphics();
		}
		//Clear the drawable area of old information
		
		buf.setColor(Color.WHITE);
		buf.fillRect(0,0,w,h);

		buf.setColor(Color.LIGHT_GRAY);
		
		// draw the "net" that shows the coordinate numbers for convenience
		drawNet(buf);
		
		
		if(sweepMode) { //different sweepmodes represent different animations, lines, rectangles or circles.
		//	((Graphics2D)buf).setPaintMode();
			buf.setColor(Color.BLACK);
			if(lineMode==1)
				buf.drawLine(0,0+sweepLine,getWidth(),0+sweepLine);
			else if(lineMode==2)
				buf.drawLine(0+sweepLine,0,0+sweepLine,getHeight());
			else if(lineMode==3)
				buf.drawLine(0+sweepLine,0,0,0+sweepLine);
			else if(lineMode==4)
				buf.drawOval(getWidth()/2-sweepLine,getHeight()/2-sweepLine,sweepLine*2,sweepLine*2);
			else if(lineMode==5)
				buf.drawRect(getWidth()/2-sweepLine,getHeight()/2-sweepLine,sweepLine*2,sweepLine*2);
			else if(lineMode==8) {
				int halfWidth = getWidth()/2;
				int halfHeight = getHeight()/2;
				double angle = sweepLine/360.0*2*Math.PI;
				buf.drawLine(halfWidth,halfHeight,(int)Math.round(halfWidth + Math.cos(angle)*halfWidth),(int)Math.round(halfHeight - Math.sin(angle)*halfHeight));
			}
		}
		else { // draw the freehand points that are saved in objects array
			buf.setColor(Color.BLACK);
			if(objects.size() > 0 && ((Drawable)objects.get(0)).getColor() != null)
				((Graphics2D)buf).setComposite(alpha);				
			for(int i=0;i<objects.size();++i) {	
				Drawable cur = (Drawable)objects.get(i);				
				int count = 1;
				if(i+count < objects.size()) {
					Drawable next = (Drawable)objects.get(i+count);
					++count;
					while(!(next instanceof Point) && i+count < objects.size()) {				
						next = (Drawable)objects.get(i+count);
						++count;
					}
					if(next instanceof Point) {
						cur.drawYourself(buf, areaSize, limits, ((Point)next).getDrawCoords(areaSize, limits),connectLines);
					}
				} else {
					cur.drawYourself(buf, areaSize, limits, null, connectLines);
				}
			}
			
			//Draw the bufferimage to the actual canvas (the whole point of double buffering)
		}
		((Graphics2D)buf).setPaintMode();
		
		g.drawImage(buffer,0,0,this);
	}
	
	// draws the coordinate net
	private void drawNet(Graphics buf2) {
		
		double[] limits = owner.getSourceLimits(this);
	
		double width = limits[1] - limits[0];
		double height = limits[2] - limits[3];
		
		double xstep = Math.round(width / 10);
		double ystep = Math.round(height / 10);
		double curX = Math.round(limits[0] - limits[0]%xstep); 
		double curY = Math.round(limits[3] - limits[3]%ystep);
		
		if(xstep == 0) {
			xstep = Math.round(width*100)/1000.0;
			curX = limits[0];
		}
		if(ystep == 0) {
			ystep = Math.round(height*100)/1000.0;
			curY = limits[3];
		}
				
		for(int i=0;i<15;++i) {
			int drawX = (int)Math.round(((curX - limits[0]) / width) * getWidth());
			buf.drawLine(drawX,0,drawX,getHeight());
			buf.drawString(""+curX,drawX-9,10+(i%2)*10);
			curX = curX + xstep;
			int drawY = (int)Math.round(((1-(curY - limits[3]) / height)) * getHeight());
			buf.drawLine(0,drawY,getWidth(),drawY);
			buf.drawString(""+curY,3,drawY+6);
			curY = curY + ystep;
		}
		
	}
	public void update(Graphics g) {
		paint(g);
	}

	// mouse is dragged around, let's draw the points and save them to objects.
	public void mouseDragged(MouseEvent e) {
		
		int y = e.getY();
		int x = e.getX();
		
		if(e.getModifiers()==16 && drawable) {
			double[] limits = owner.getSourceLimits(this);
			
			double width = limits[1] - limits[0];
			double height = limits[2] - limits[3];	
					
			double actualX = limits[0] + ((1.0*x) / getWidth()) * width;
			double actualY = limits[2] - ((1.0*y) / getHeight()) * height;
			
			if(owner.sweepMode != -1)
				owner.exitSweepMode();
			if(pointExists(actualX, actualY) == null) {
				objects.add(new Point(actualX,actualY));
				repaint();
				owner.triggerMapping();
			}
		} else if(e.getModifiers()==4) {
			owner.moveCoordinates(x-prevX, y-prevY, this, false);
			prevX = x;
			prevY = y;
		}
	}
	private Point pointExists(double x, double y) {
		for(int i=0;i<objects.size();++i) {
			Drawable b = (Drawable)objects.get(i);
			if(b instanceof Point && ((Point)b).x == x && ((Point)b).y == y) {
				return (Point)b;				
			}
		}
		return null;
	}
	public void mouseMoved(MouseEvent e) {
				
	}
	public void mouseClicked(MouseEvent e) {
		
	}
	public void mousePressed(MouseEvent e) {
		if (e.getModifiers() == 16 && drawable) {
			if(owner.sweepMode != -1)
				owner.exitSweepMode(true);
		}
		else if (e.getModifiers() == 4) {
			prevX = e.getX();
			prevY = e.getY();
		}
	}
	public void mouseReleased(MouseEvent e) {
		int y = e.getY();
		int x = e.getX();
		if(e.getModifiers() == 16 && drawable) {			
			double[] limits = owner.getSourceLimits(this);
		
			double width = limits[1] - limits[0];
			double height = limits[2] - limits[3];	
					
			double actualX = limits[0] + ((1.0*x) / getWidth()) * width;
			double actualY = limits[2] - ((1.0*y) / getHeight()) * height;
			
			Point last = pointExists(actualX, actualY);
			if(last == null) {
				last = new Point(actualX,actualY);
				objects.add(last);
			}
			last.setLast(true);		
			repaint();
			owner.triggerMapping();
		} else if (e.getModifiers() == 4) {
			owner.moveCoordinates(x-prevX, y-prevY, this, true);
		}
	}
	public void mouseEntered(MouseEvent e) {
		
	}
	public void mouseExited(MouseEvent e) {
	}
	public void clearPoints() {
		this.fillMode = false;
		this.gridMode = false;
		objects.clear();
		repaint();		
	}
	public void mapPoints(ArrayList points) {
		owner.refreshParsers();
		owner.clearPointCache();
		ArrayList mapped = new ArrayList();
		for(int i=0;i<objects.size();++i) {
			mapped.add((Point)objects.get(i));
		}
		for(int i=0;i<points.size();++i) {
			 Drawable cur = (Drawable)points.get(i);
			 if(cur instanceof Point) {
				 Point curPoint = (Point)cur;
				 if(!curPoint.mapped) {
					 double[] coords = owner.getMappedCoords(curPoint.x, curPoint.y);
					 curPoint.mappedX = coords[0];
					 curPoint.mappedY = coords[1];

					 Point check = new Point(coords[0], coords[1]);
					 mapped.add(check);

					 check.last = curPoint.last;
					 check.color = curPoint.color;
					 check.radius = curPoint.radius;
					 curPoint.mapped = true;
				 }
				 if(curPoint.last) {
					 try {
						 ((Point)mapped.get(i)).last = true;
					 }catch(Exception ex) {
						 
					 }
				 }
			 }
		}
		objects = mapped;
		repaint();		
	}
	public void clearMappings() {				
		for(int i=0;i<objects.size();++i) {
			Drawable cur = (Drawable)objects.get(i);
			if(cur instanceof Point) {
				((Point)cur).mapped = false;
			}
		}
	}
	public void drawSweepLine(int counter, int lineMode) {
		sweepLine = counter;
		this.lineMode = lineMode;
		repaint();		
	}
	public void sweepMode(boolean b) {
		this.fillMode = false;
		this.gridMode = false;
		this.sweepMode = b;		
	}
	public void fill() {
		//this.fillMode = true;
		repaint();		
	}

	public void grid() {
		//this.gridMode = true;
		repaint();
		
	}	
}