import java.awt.*;
import java.awt.Canvas;
import java.util.*;
import java.awt.image.*;
import java.awt.event.*;

public class nCanvas extends Canvas {
    Image buffImage;
    Graphics gBuff;
	boolean pixels[][];
    
	double rx0=0.0, ry0=0.0, rx1=1.0, ry1=1.0; 
		// real coord of left-bottom point and right-top point
	double rwidth=1.0, rheight=1.0;
        // width and hwight in real
		    
    public void makeBuffer(){
        Dimension ps=getSize();
        
        buffImage=createImage(ps.width,ps.height);

        if(buffImage==null){ System.out.println("Could not make buffer.");}
        
        gBuff=buffImage.getGraphics();
        pixels= new boolean[ps.width][ps.height];
    }

	public void paint(Graphics g){        
        g.drawImage(buffImage,0,0,this);
	}
	
	public void update(Graphics g){
        paint(g);
	}
	
	//set screen size in real coordinate
    public void screen(double x0, double y0, double x1, double y1){
		double tmp;
		
		if(x0>x1){ tmp=x0; x0=x1; x1=tmp;};
		if(y0>y1){ tmp=y0; y0=y1; y1=tmp;};
		
		rx0=x0; ry0=y0; rx1=x1; ry1=y1;
		rwidth=rx1-rx0; rheight=ry1-ry0;
	}
	
    //clear screen
	public void eraseBuff(){
        Dimension ps=getSize();
		Color tmpcol;
		
        // gBuff.clearRect(0,0,ps.width,ps.height);
		tmpcol=gBuff.getColor();
		gBuff.setColor(Color.white);
		gBuff.fillRect(0,0,ps.width,ps.height);
        update(this.getGraphics());
        for(int xi=0; xi<ps.width; xi++){
            for(int yi=0; yi<ps.height; yi++){
                pixels[xi][yi]=true;  //true if the point is white.
            }
        }
		gBuff.setColor(tmpcol);
	}
	
    
	// POINT *****************************
        
    //draw point
	public void drawPoint(int x, int y){
        gBuff.setColor(getForeground());
        if(pixels[x][y]){  //if the point is not colored
            gBuff.drawLine(x,y, x,y);
            repaint(1,x,y,1,1);
            pixels[x][y]=false;
        }
    }
	
    //draw point in Dimension
	public void drawPoint(Dimension pt){
        drawPoint(pt.width, pt.height);
	}
	
    //draw point in real coordinate
	public void drawPoint(double x, double y){
		int xi, yi;
		Dimension s = getSize();
        Color col;
				
        if((rx0<=x) && (x<rx1) && (ry0<=y) && (y<ry1)){
            xi=(int)(Math.floor(((double)s.width * (x-rx0) / rwidth)));
            yi=s.height-(int)(Math.ceil(((double)s.height * (y-ry0) / rheight)));
            drawPoint(xi,yi);
        } 
    }

	// LINE *****************************
    
    //draw line in integer coord
    public void drawLine(int x0, int y0, int x1, int y1){
        gBuff.setColor(getForeground());
        gBuff.drawLine(x0,y0, x1,y1);
        //System.out.println("Integer : ("+x0+", "+y0+") - ("+x1+", "+y1+")");
        repaint();
    }
    
    // draw line in real coord
	public void drawLine(double x0, double y0, double x1, double y1){
		drawLine(xInt(x0),yInt(y0), xInt(x1), yInt(y1));
	}

	// draw TEMPORARY line in integer coord
	
	public void drawLineTemp(int x0, int y0, int x1, int y1){
		Graphics gtmp=getGraphics();
        
		gtmp.setColor(getForeground());
		gtmp.drawLine(x0,y0, x1,y1);
		gtmp.dispose();
	}
	
	// draw TEMPORARY line in real coord
	public void drawLineTemp(double x0, double y0, double x1, double y1){
		drawLineTemp(xInt(x0),yInt(y0), xInt(x1), yInt(y1));
	}
	
	// RECTANGLE *****************************
	
	// draw rectangle in integer coord [x1,y1 are coordinates!!]
	public void drawRect(int x0, int y0, int x1, int y1){
		int w,h;
		
		w=Math.abs(x0-x1); x0=Math.min(x0,x1);
		h=Math.abs(y0-y1); y0=Math.min(y0,y1);
		
		/*
        gtmp=getGraphics();
		gtmp.setColor(getForeground());
		gtmp.drawRect(x0,y0, w,h);
		gtmp.dispose();
		gBuff.setColor(getForeground());
		*/
        gBuff.setColor(getForeground());
        gBuff.drawRect(x0,y0, w,h);
        repaint();
	}
	
	// draw rectangle in real coord
	public void drawRect(double x0, double y0, double x1, double y1){
		drawRect(xInt(x0),yInt(y0), xInt(x1), yInt(y1));
	}

	// draw TEMPORARY rectangle in integer coord [x1,y1 are coordinates!!]
	public void drawRectTemp(int x0, int y0, int x1, int y1){
		int w,h;
		Graphics gtmp=getGraphics();
        		
		w=Math.abs(x0-x1); x0=Math.min(x0,x1);
		h=Math.abs(y0-y1); y0=Math.min(y0,y1);
		
		gtmp.setColor(getForeground());
		gtmp.drawRect(x0,y0, w,h);
		gtmp.dispose();
	}

	// draw TEMPORARY rectangle in real coord
	public void drawRectTemp(double x0, double y0, double x1, double y1){
		drawRectTemp(xInt(x0),yInt(y0), xInt(x1), yInt(y1));
	}
	
	// POLYGON *****************************
	
	// draw polygon in integer coord
	public void drawPolygon(int xPoints[], int yPoints[], int n){
		
		/*
        gtmp=getGraphics();
		gtmp.setColor(getForeground());
		gtmp.drawPolygon(xPoints, yPoints, n);
		gtmp.dispose();
		gBuff.setColor(getForeground());
		*/
        gBuff.setColor(getForeground());
        gBuff.drawPolygon(xPoints, yPoints, n);
        repaint();
	}
	
	// draw polygon in real coord
	public void drawPolygon(double xPoints[], double yPoints[], int n){
		int xi[] = new int[n];
		int yi[] = new int[n];
		int i;
		
		for(i=0;i<n;i++){
			xi[i]=xInt(xPoints[i]);
			yi[i]=yInt(yPoints[i]);
		}
		drawPolygon(xi,yi,n);
	}
	
	// draw TEMPORARY polygon in integer coord
	public void drawPolygonTemp(int xPoints[], int yPoints[], int n){
		Graphics gtmp=getGraphics();
        
		gtmp.setColor(getForeground());
		gtmp.drawPolygon(xPoints, yPoints, n);
		gtmp.dispose();
	}
	
	// draw TEMPORARY polygon in real coord
	public void drawPolygonTemp(double xPoints[], double yPoints[], int n){
		int xi[] = new int[n];
		int yi[] = new int[n];
		int i;
		
		for(i=0;i<n;i++){
			xi[i]=xInt(xPoints[i]);
			yi[i]=yInt(yPoints[i]);
		}
		drawPolygonTemp(xi,yi,n);
	}
	
	// fill polygon in integer coord
	public void fillPolygon(int xPoints[], int yPoints[], int n){
		
		/*
        gtmp=getGraphics();
		gtmp.setColor(getForeground());
		gtmp.fillPolygon(xPoints, yPoints, n);
		gtmp.dispose();
		gBuff.setColor(getForeground());
		*/
        gBuff.setColor(getForeground());
        gBuff.fillPolygon(xPoints, yPoints, n);
        repaint();
	}
	
	// fill polygon in real coord
	public void fillPolygon(double xPoints[], double yPoints[], int n){
		int xi[] = new int[n];
		int yi[] = new int[n];
		int i;
		
		for(i=0;i<n;i++){
			xi[i]=xInt(xPoints[i]);
			yi[i]=yInt(yPoints[i]);
		}
		fillPolygon(xi,yi,n);
	}

	
    // TEMPORARY Mark
    // draw TEMPORARY mark in integer coord
	public void drawMarkTemp(int x, int y){
		Graphics gtmp=getGraphics();
        
		gtmp.setColor(getForeground());
		gtmp.fillOval(x-1,y-1,2,2);
		gtmp.dispose();
	}
	
	// draw TEMPORARY mark in real coord
	public void drawMarkTemp(double x, double y){
		drawMarkTemp(xInt(x),yInt(y));
	}
	
    
    // GET POSITION OF EVENT ****************************
	// get x-position of the event in real
	public double eventRX(MouseEvent event){
		return(xDouble(event.getX()));
	}
	
	// get y-position of the event in real
	public double eventRY(MouseEvent event){
		return(yDouble(event.getY()));
	}
	

	// COORDINATE TRANSLATION *****************************
	
	// change x coord from real to integer
	public int xInt(double x){
        Dimension sz=getSize();
        
		return((int)(Math.floor((double)sz.width * (x-rx0) / rwidth)));
	}
	
	// change y coord from real to integer
	public int yInt(double y){
        Dimension sz=getSize();
        
		return(sz.height-(int)(Math.ceil((double)sz.height * (y-ry0) / rheight)));
	}
	
	// change x coord from integer to real
	public double xDouble(int x){
        Dimension sz=getSize();
        
		return(rx0 + (double)x/(double)sz.width * rwidth);
	}
	
	// change y coord from integer to real
	public double yDouble(int y){
        Dimension sz=getSize();
        
		return(ry0 + (double)(sz.height-y)/(double)sz.height * rheight);
	}
}