/*****************************************************************************
**  Copyright (C) 1998-2001  Ljubomir Milanovic & Horst Wagner
**  This file is part of the g2 library
**
**  This library is free software; you can redistribute it and/or
**  modify it under the terms of the GNU Lesser General Public
**  License as published by the Free Software Foundation; either
**  version 2.1 of the License, or (at your option) any later version.
**
**  This library is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
**  Lesser General Public License for more details.
**
**  You should have received a copy of the GNU Lesser General Public
**  License along with this library; if not, write to the Free Software
**  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
******************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include "g2_funix.h"
#include "g2_virtual_device.h"
#include "g2_graphic_pd.h"
#include "g2_control_pd.h"
#include "g2_util.h"

#ifndef PI
#define PI 3.14159265358979323846
#endif /* PI */


/*
 *
 * Plot (physical device)
 *
 */
void g2_plot_pd(g2_physical_device *pd, double x, double y)
{
    int    ix, iy;
    double dx, dy;
    
    if(pd->ff[g2_Plot].fun!=NULL) {
	switch(pd->coor_type) {
	  case g2_IntCoor:
	    g2_uc2pdc_int(pd, x, y, &ix, &iy);
	    pd->ff[g2_Plot].fun(pd->pid, pd->pdp,
				ix, iy);
	    break;
	  case g2_DoubleCoor:
	    g2_uc2pdc_double(pd, x, y, &dx, &dy);
	    pd->ff[g2_Plot].fun(pd->pid, pd->pdp,
				dx, dy);
	    break;
	}
    } else {
	/* emulate ... with .... */  
    }
}



/*
 *
 * Draw line (low_level)
 *
 */
void g2_line_pd(g2_physical_device *pd,
		double x1, double y1, double x2, double y2)
{
    int    ix1, iy1, ix2, iy2;
    double dx1, dy1, dx2, dy2;
    
    if(pd->ff[g2_Line].fun!=NULL) {
	switch(pd->coor_type) {
	  case g2_IntCoor:
	    g2_uc2pdc_int(pd, x1, y1, &ix1, &iy1);
	    g2_uc2pdc_int(pd, x2, y2, &ix2, &iy2);
	    pd->ff[g2_Line].fun(pd->pid, pd->pdp,
				ix1, iy1, ix2, iy2);
	    break;
	  case g2_DoubleCoor:
	    g2_uc2pdc_double(pd, x1, y1, &dx1, &dy1);
	    g2_uc2pdc_double(pd, x2, y2, &dx2, &dy2);
	    pd->ff[g2_Line].fun(pd->pid, pd->pdp,
				dx1, dy1, dx2, dy2);
	    break;
	}		
    } else {
	/* emulate ... with .... */  
    }
}



/*
 *
 * Draw poly line (physical device)
 *
 */
void g2_poly_line_pd(g2_physical_device *pd,
		     int N, double *points)
{
    int i;
    int    *ipt;
    double *dpt;
    
    if(pd->ff[g2_PolyLine].fun!=NULL) {
	switch(pd->coor_type) {
	  case g2_IntCoor:
	    ipt=g2_malloc(2*N*sizeof(int));
	    for(i=0;i<2*N;i+=2)
		g2_uc2pdc_int(pd, points[i+0], points[i+1], ipt+i, ipt+i+1);
	    pd->ff[g2_PolyLine].fun(pd->pid, pd->pdp,
				    N, ipt);
	    free(ipt);
	    break;
	  case g2_DoubleCoor:
	    dpt=g2_malloc(2*N*sizeof(double));
	    for(i=0;i<2*N;i+=2)
		g2_uc2pdc_double(pd,
				  points[i+0], points[i+1],
				  dpt+i, dpt+i+1);
	    pd->ff[g2_PolyLine].fun(pd->pid, pd->pdp,
				    N, dpt);
	    free(dpt);
	    break;
	}
    } else {
	for (i=0;i<N-1;i++)		 /* emulate polyline with lines */  
	    g2_line_pd(pd,
		       points[2*i], points[2*i+1],
		       points[2*i+2], points[2*i+3]);
    }
}



/*
 *
 * Triangle (physical device)
 *
 */
void g2_triangle_pd(g2_physical_device *pd,
		    double x1, double y1,
		    double x2, double y2,
		    double x3, double y3)
{
    int    ix1, iy1, ix2, iy2, ix3, iy3;
    double dx1, dy1, dx2, dy2, dx3, dy3;
    
    if(pd->ff[g2_Triangle].fun!=NULL) {
	switch(pd->coor_type) {
	  case g2_IntCoor:
	    g2_uc2pdc_int(pd, x1, y1, &ix1, &iy1);
	    g2_uc2pdc_int(pd, x2, y2, &ix2, &iy2);
	    g2_uc2pdc_int(pd, x3, y3, &ix3, &iy3);
	    pd->ff[g2_Triangle].fun(pd->pid, pd->pdp,
				    ix1, iy1,
				    ix2, iy2,
				    ix3, iy3);
	    break;
	  case g2_DoubleCoor:
	    g2_uc2pdc_double(pd, x1, y1, &dx1, &dy1);
	    g2_uc2pdc_double(pd, x2, y2, &dx2, &dy2);
	    g2_uc2pdc_double(pd, x3, y3, &dx3, &dy3);
	    pd->ff[g2_Triangle].fun(pd->pid, pd->pdp,
				    dx1, dy1,
				    dx2, dy2,
				    dx3, dy3);
	}		
    } else {
	g2_line_pd(pd, x1, y1, x2, y2);      /* emulate triangle with lines */
	g2_line_pd(pd, x2, y2, x3, y3);
	g2_line_pd(pd, x3, y3, x1, y1);
    }
}



/*
 *
 * Filled triangle (physical device)
 *
 */
void g2_filled_triangle_pd(g2_physical_device *pd,
			   double x1, double y1,
			   double x2, double y2,
			   double x3, double y3)
{
    int    ix1, iy1, ix2, iy2, ix3, iy3;
    double dx1, dy1, dx2, dy2, dx3, dy3;
    
    if(pd->ff[g2_FilledTriangle].fun!=NULL) {
	switch(pd->coor_type) {
	  case g2_IntCoor:
	    g2_uc2pdc_int(pd, x1, y1, &ix1, &iy1);
	    g2_uc2pdc_int(pd, x2, y2, &ix2, &iy2);
	    g2_uc2pdc_int(pd, x3, y3, &ix3, &iy3);
	    pd->ff[g2_FilledTriangle].fun(pd->pid, pd->pdp,
					  ix1, iy1,
					  ix2, iy2,
					  ix3, iy3);
	    break;
	  case g2_DoubleCoor:
	    g2_uc2pdc_double(pd, x1, y1, &dx1, &dy1);
	    g2_uc2pdc_double(pd, x2, y2, &dx2, &dy2);
	    g2_uc2pdc_double(pd, x3, y3, &dx3, &dy3);
	    pd->ff[g2_FilledTriangle].fun(pd->pid, pd->pdp,
					  dx1, dy1,
					  dx2, dy2,
					  dx3, dy3);
	}		
    } else {
	double Triangle[6];     /* emulate FilledTriangle with FilledPolygon */
	Triangle[0] = x1;
	Triangle[1] = y1;
	Triangle[2] = x2;
	Triangle[3] = y2;
	Triangle[4] = x3;
	Triangle[5] = y3;
	g2_filled_polygon_pd(pd, 3, Triangle); 
    }
}



/*
 *
 * Rectangle (physical device)
 *
 */
void g2_rectangle_pd(g2_physical_device *pd,
		     double x1, double y1, double x2, double y2)
{
    int    ix1, iy1, ix2, iy2;
    double dx1, dy1, dx2, dy2;
    
    if(pd->ff[g2_Rectangle].fun!=NULL) {
	switch(pd->coor_type) {
	  case g2_IntCoor:
	    g2_uc2pdc_int(pd, x1, y1, &ix1, &iy1);
	    g2_uc2pdc_int(pd, x2, y2, &ix2, &iy2);
	    g2_sort2_i(&ix1, &ix2);
	    g2_sort2_i(&iy1, &iy2);
	    pd->ff[g2_Rectangle].fun(pd->pid, pd->pdp,
				     ix1, iy1, ix2, iy2);
	    break;
	  case g2_DoubleCoor:
	    g2_uc2pdc_double(pd, x1, y1, &dx1, &dy1);
	    g2_uc2pdc_double(pd, x2, y2, &dx2, &dy2);
	    g2_sort2_d(&dx1, &dx2);
	    g2_sort2_d(&dy1, &dy2);
	    pd->ff[g2_Rectangle].fun(pd->pid, pd->pdp,
				     dx1, dy1, dx2, dy2);
	    break;
	}		
    } else {
	g2_line_pd(pd, x1, y1, x1, y2);     /* emulate rectangle with lines */
	g2_line_pd(pd, x1, y1, x2, y1);
	g2_line_pd(pd, x2, y1, x2, y2);
	g2_line_pd(pd, x1, y2, x2, y2);
    }
}



/*
 *
 * Filled rectangle (physical device)
 *
 */
void g2_filled_rectangle_pd(g2_physical_device *pd,
			    double x1, double y1, double x2, double y2)
{
    int    ix1, iy1, ix2, iy2;
    double dx1, dy1, dx2, dy2;
    
    if(pd->ff[g2_FilledRectangle].fun!=NULL) {
	switch(pd->coor_type) {
	  case g2_IntCoor:
	    g2_uc2pdc_int(pd, x1, y1, &ix1, &iy1);
	    g2_uc2pdc_int(pd, x2, y2, &ix2, &iy2);
	    g2_sort2_i(&ix1, &ix2);
	    g2_sort2_i(&iy1, &iy2);
	    pd->ff[g2_FilledRectangle].fun(pd->pid, pd->pdp,
					   ix1, iy1, ix2, iy2);
	    break;
	  case g2_DoubleCoor:
	    g2_uc2pdc_double(pd, x1, y1, &dx1, &dy1);
	    g2_uc2pdc_double(pd, x2, y2, &dx2, &dy2);
	    g2_sort2_d(&dx1, &dx2);
	    g2_sort2_d(&dy1, &dy2);
	    pd->ff[g2_FilledRectangle].fun(pd->pid, pd->pdp,
					   dx1, dy1, dx2, dy2);
	    break;
	}		
    } else {
	double Rectangle[8];  /* emulate FilledRectangle with FilledPolygon */
	Rectangle[0] = x1;
	Rectangle[1] = y1;
	Rectangle[2] = x2;
	Rectangle[3] = y1;
	Rectangle[4] = x2;
	Rectangle[5] = y2;
	Rectangle[6] = x1;
	Rectangle[7] = y2;
	g2_filled_polygon_pd(pd,4,Rectangle);
    }
}



/*
 *
 * Polygon (physical device)
 *
 */
void g2_polygon_pd(g2_physical_device *pd,
		   int N, double *points)
{
    int i;
    int    *ipt;
    double *dpt;
    
    if(pd->ff[g2_Polygon].fun!=NULL) {
	switch(pd->coor_type) {
	  case g2_IntCoor:
	    ipt=g2_malloc(2*N*sizeof(int));
	    for(i=0;i<2*N;i+=2)
		g2_uc2pdc_int(pd, points[i+0], points[i+1], ipt+i, ipt+i+1);
	    pd->ff[g2_Polygon].fun(pd->pid, pd->pdp,
				   N, ipt);
	    free(ipt);
	    break;
	  case g2_DoubleCoor:
	    dpt=g2_malloc(2*N*sizeof(double));
	    for(i=0;i<2*N;i+=2)
		g2_uc2pdc_double(pd,
				  points[i+0], points[i+1], dpt+i, dpt+i+1);
	    pd->ff[g2_Polygon].fun(pd->pid, pd->pdp,
				   N, dpt);
	    free(dpt);
	    break;
	}
    } else {
	for (i=0;i<N-1;i++)       /* emulate polygon with lines */
	    g2_line_pd(pd,
		       points[2*i], points[2*i+1],
		       points[2*i+2], points[2*i+3]);
	g2_line_pd(pd,points[2*N-2], points[2*N-1],points[0], points[1]);
    }
}



/*
 *
 * Filled polygon (physical device)
 *
 */
void g2_filled_polygon_pd(g2_physical_device *pd,
			  int N, double *points)
{
    int i;
    int    *ipt;
    double *dpt;

    if(pd->ff[g2_FilledPolygon].fun!=NULL) {
	switch(pd->coor_type) {
	  case g2_IntCoor:
	    ipt=g2_malloc(2*N*sizeof(int));
	    for(i=0;i<2*N;i+=2)
		g2_uc2pdc_int(pd, points[i+0], points[i+1], ipt+i, ipt+i+1);
	    pd->ff[g2_FilledPolygon].fun(pd->pid, pd->pdp,
					 N, ipt);
	    free(ipt);
	    break;
	  case g2_DoubleCoor:
	    dpt=g2_malloc(2*N*sizeof(double));
	    for(i=0;i<2*N;i+=2)
		g2_uc2pdc_double(pd,
				  points[i+0], points[i+1], dpt+i, dpt+i+1);
	    pd->ff[g2_FilledPolygon].fun(pd->pid, pd->pdp,
					 N, dpt);
	    free(dpt);
	    break;
	}
    } else {
	/* emulate filled polygon with .... */  
    }
}



/*
 *
 * Ellipse (physical device)
 *
 */
void g2_ellipse_pd(g2_physical_device *pd,
		   double x, double y, double r1, double r2)
{
    int    ix, iy, ir1, ir2;
    double dx, dy, dr1, dr2;

    if(pd->ff[g2_Ellipse].fun!=NULL) {
	switch(pd->coor_type) {
	  case g2_IntCoor:
	    g2_uc2pdc_int(pd, x, y, &ix, &iy);
	    g2_us2pds_int(pd, r1, r2, &ir1, &ir2);
	    pd->ff[g2_Ellipse].fun(pd->pid, pd->pdp,
				   ix, iy, ir1, ir2);
	    break;
	  case g2_DoubleCoor:
	    g2_uc2pdc_double(pd, x, y, &dx, &dy);
	    g2_us2pds_double(pd, r1, r2, &dr1, &dr2);
	    pd->ff[g2_Ellipse].fun(pd->pid, pd->pdp,
				   dx, dy, dr1, dr2);
	    break;
	}
    } else {
	g2_arc_pd(pd, x, y, r1, r2, 0., 360.);   /* emulate ellipse with arc */
    }
}



/*
 *
 * Filled ellipse (physical device)
 *
 */
void g2_filled_ellipse_pd(g2_physical_device *pd,
			  double x, double y, double r1, double r2)
{
    int    ix, iy, ir1, ir2;
    double dx, dy, dr1, dr2;

    if(pd->ff[g2_FilledEllipse].fun!=NULL) {
	switch(pd->coor_type) {
	  case g2_IntCoor:
	    g2_uc2pdc_int(pd, x, y, &ix, &iy);
	    g2_us2pds_int(pd, r1, r2, &ir1, &ir2);
	    pd->ff[g2_FilledEllipse].fun(pd->pid, pd->pdp,
					 ix, iy, ir1, ir2);
	    break;
	  case g2_DoubleCoor:
	    g2_uc2pdc_double(pd, x, y, &dx, &dy);
	    g2_us2pds_double(pd, r1, r2, &dr1, &dr2);
	    pd->ff[g2_FilledEllipse].fun(pd->pid, pd->pdp,
					 dx, dy, dr1, dr2);
	    break;
	}
    } else {
	g2_filled_arc_pd(pd,        /* emulate filledellipse with filled arc */
			 x, y,
			 r1, r2,
			 0., 360.);
    }
}



/*
 *
 * Circle (physical device)
 *
 */
void g2_circle_pd(g2_physical_device *pd,
		  double x, double y, double r)
{
    int    ix, iy, ir;
    double dx, dy, dr;

    if(pd->ff[g2_Circle].fun!=NULL) {
	switch(pd->coor_type) {
	  case g2_IntCoor:
	    g2_uc2pdc_int(pd, x, y, &ix, &iy);
	    g2_us2pds_int(pd, r, 0, &ir, NULL);
	    pd->ff[g2_Circle].fun(pd->pid, pd->pdp,
				  ix, iy, ir);
	    break;
	  case g2_DoubleCoor:
	    g2_uc2pdc_double(pd, x, y, &dx, &dy);
	    g2_us2pds_double(pd, r, 0, &dr, NULL);
	    pd->ff[g2_Circle].fun(pd->pid, pd->pdp,
				  dx, dy, dr);
	    break;
	}
    } else {
	g2_ellipse_pd(pd, x, y, r, r);	     /* emulate circle with ellipse */
    }   
}



/*
 *
 * Filled circle (physical device)
 *
 */
void g2_filled_circle_pd(g2_physical_device *pd,
			 double x, double y, double r)
{
    int    ix, iy, ir;
    double dx, dy, dr;

    if(pd->ff[g2_FilledCircle].fun!=NULL) {
	switch(pd->coor_type) {
	  case g2_IntCoor:
	    g2_uc2pdc_int(pd, x, y, &ix, &iy);
	    g2_us2pds_int(pd, r, 0, &ir, NULL);
	    pd->ff[g2_FilledCircle].fun(pd->pid, pd->pdp,
					ix, iy, ir);
	    break;
	  case g2_DoubleCoor:
	    g2_uc2pdc_double(pd, x, y, &dx, &dy);
	    g2_us2pds_double(pd, r, 0, &dr, NULL);
	    pd->ff[g2_FilledCircle].fun(pd->pid, pd->pdp,
					dx, dy, dr);
	    break;
	}
    } else {
	g2_filled_ellipse_pd(pd, x, y, r, r);           /* emulate */
    }   
}



/*
 *
 * Arc (physical device)
 *
 */
void g2_arc_pd(g2_physical_device *pd,
	       double x, double y, double r1, double r2, double a1, double a2)
{
    int    ix, iy, ir1, ir2;
    double dx, dy, dr1, dr2;
	
    if(pd->ff[g2_Arc].fun!=NULL) {
	switch(pd->coor_type) {
	  case g2_IntCoor:
	    g2_uc2pdc_int(pd, x, y, &ix, &iy);
	    g2_us2pds_int(pd, r1, r2, &ir1, &ir2);
	    pd->ff[g2_Arc].fun(pd->pid, pd->pdp,
			       ix, iy, ir1, ir2, a1, a2);
	    break;
	  case g2_DoubleCoor:
	    g2_uc2pdc_double(pd, x, y, &dx, &dy);
	    g2_us2pds_double(pd, r1, r2, &dr1, &dr2);
	    pd->ff[g2_Arc].fun(pd->pid, pd->pdp,
			       dx, dy, dr1, dr2, a1, a2);
	    break;
	}
    } else {
	double a, da, *pt;			  /* emulate arc */
	int N, i;
	N=(a2==a1)?360:(int)fabs(a2-a1)+8;
	a=a1*2.*PI/360.;
	da=((a2>a1)? (a2-a1):360.-(a1-a2))*2.*PI/360./(N-1);
	pt=g2_malloc(2*N*sizeof(double));
	for(i=0;i<N;i++) {
	    pt[2*i+0]=x+r1*cos(a+i*da);
	    pt[2*i+1]=y+r2*sin(a+i*da);
	}
	g2_poly_line_pd(pd, N, pt);		  /* using poly_line */
	g2_free(pt);
    }
}



/*
 *
 * Filled arc (physical device)
 *
 */
void g2_filled_arc_pd(g2_physical_device *pd,
		      double x, double y,
		      double r1, double r2,
		      double a1, double a2)
{
    int    ix, iy, ir1, ir2;
    double dx, dy, dr1, dr2;
    	
    if(pd->ff[g2_FilledArc].fun!=NULL) {
	switch(pd->coor_type) {
	  case g2_IntCoor:
	    g2_uc2pdc_int(pd, x, y, &ix, &iy);
	    g2_us2pds_int(pd, r1, r2, &ir1, &ir2);
	    pd->ff[g2_FilledArc].fun(pd->pid, pd->pdp,
				     ix, iy, ir1, ir2, a1, a2);
	    break;
	  case g2_DoubleCoor:
	    g2_uc2pdc_double(pd, x, y, &dx, &dy);
	    g2_us2pds_double(pd, r1, r2, &dr1, &dr2);
	    pd->ff[g2_FilledArc].fun(pd->pid, pd->pdp,
				     dx, dy, dr1, dr2, a1, a2);
	    break;
	}
    } else {
	double a, da, *pt;			  /* emulate filled arc */
	int N, i;
	N=(a2==a1)?360:(int)fabs(a2-a1)+8;
	a=a1*2.*PI/360.;
	da=((a2>a1)? (a2-a1):360.-(a1-a2))*2.*PI/360./(N-1);
	pt=g2_malloc(2*(N+2)*sizeof(double));
	pt[0]=x;
	pt[1]=y;
	for(i=0;i<N;i++) {
	    pt[2*i+2]=x+r1*cos(a+i*da);
	    pt[2*i+3]=y+r2*sin(a+i*da);
	}
	pt[2*N+2]=x;
	pt[2*N+3]=y;
	g2_filled_polygon_pd(pd, N+2, pt);	  /* using filled polygon */
	g2_free(pt);
    }
}



/*
 *
 * Draw string (physical device)
 *
 */
void g2_string_pd(g2_physical_device *pd,
		  double x, double y, const char *text)
{
    int    ix, iy;
    double dx, dy;

    if(pd->ff[g2_String].fun!=NULL) {
	switch(pd->coor_type) {
	  case g2_IntCoor:
	    g2_uc2pdc_int(pd, x, y, &ix, &iy);
	    pd->ff[g2_String].fun(pd->pid, pd->pdp,
				  ix, iy, text);
	    break;
	  case g2_DoubleCoor:
	    g2_uc2pdc_double(pd, x, y, &dx, &dy);
	    pd->ff[g2_String].fun(pd->pid, pd->pdp,
				  dx, dy, text);
	    break;
	}
    } else {
	/* emulate ... with .... */  
    }
}



void g2_image_pd(g2_physical_device *pd,
	      double x, double y, int x_size, int y_size, int *pens)
{
    int    ix, iy;
    double dx, dy;

    if(pd->ff[g2_Image].fun!=NULL) {
	switch(pd->coor_type) {
	  case g2_IntCoor:
	    g2_uc2pdc_int(pd, x, y, &ix, &iy);
	    pd->ff[g2_Image].fun(pd->pid, pd->pdp,
				 ix, iy, x_size, y_size, pens);
	    break;
	  case g2_DoubleCoor:
	    g2_uc2pdc_double(pd, x, y, &dx, &dy);
	    pd->ff[g2_Image].fun(pd->pid, pd->pdp,
				 dx, dy, x_size, y_size, pens);
	    break;
	}
    } else {
	for(ix=0;ix<x_size;ix++) 
	    for(iy=0;iy<y_size;iy++) {
		g2_pen_pd(pd, pens[ix+x_size*iy]);
		g2_plot_pd(pd, ix+x, (y_size-iy-1)+y);
	    }
    }
}