g2_graphic_pd.c

ViennaRNA-1.6.1

/*****************************************************************************
**  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);