blib_graph.c

smallbasic for linux

/*
*	SmallBasic LIBRARY - GRAPHICS
*
*	2000-05-27, Nicholas Christopoulos
*
*	This program is distributed under the terms of the GPL v2.0 or later
*	Download the GNU Public License (GPL) from www.gnu.org
*/

#include "sys.h"
#include "str.h"
#include "kw.h"
#include "panic.h"
#include "var.h"
#include "blib.h"
#include "pproc.h"

// graphics - rel. coord.
static int  gra_x;
static int  gra_y;

//
void	graph_reset()
{
	gra_x = gra_y = 0;
	dev_cls();
}

//
//	PSET [STEP] x, y [COLOR color]
//
void	cmd_pset()
{
	int		x1, y1;
	int		color = dev_fgcolor, step1 = 0;

	/* [STEP] x, y */
	if	( code_peek() == kwSTEP )	{
		code_skipnext();
		step1 = 1;
		}

	x1 = par_getint();	if ( prog_error )	return;
	par_getcomma();		if ( prog_error )	return;
	y1 = par_getint();	if ( prog_error )	return;
	if	( step1 )
		(x1 += gra_x, y1 += gra_y);

	if	( code_peek() == kwCOLOR )	{
		code_skipnext();
		color = par_getint();	if ( prog_error )	return;
		}

	gra_x = x1;
	gra_y = y1;

	if	( color != dev_fgcolor )	{
		int		prev_color = dev_fgcolor;

		dev_setcolor(color);
		dev_setpixel(x1, y1);
		dev_setcolor(prev_color);
		}
	else
		dev_setpixel(x1, y1);
}

//
//	LINE [STEP] x, y [{,|STEP} x2, y2] [COLOR color]
//
void	cmd_line()
{
	int		x1, y1,	x2, y2;
	int		step1 = 0, step2 = 0;
	int		color = dev_fgcolor;
	byte	code;

	/* [STEP] x, y */
	code = code_peek();
	if	( code == kwSTEP )	{
		code_skipnext();
		step1 = 1;
		}

	x1 = par_getint();	if ( prog_error )	return;
	par_getcomma();		if ( prog_error )	return;
	y1 = par_getint();	if ( prog_error )	return;
	if	( step1 )
		( x1 += gra_x, y1 += gra_y );

	code = code_peek();
	if	( code == kwTYPE_SEP || code == kwSTEP )	{
		/* x, y [STEP] ? */
		if	( code == kwSTEP )	{
			code_skipnext();
			step2 = 1;
			}
		else
			par_getcomma();		if ( prog_error )	return;

		/* [STEP] x, y [,|STEP] x2, y2 */
		x2 = par_getint();	if ( prog_error )	return;
		par_getcomma();		if ( prog_error )	return;
		y2 = par_getint();	if ( prog_error )	return;
		if	( step2 )
			( x2 += x1, y2 += y1 );
		}
	else	{
		x2 = x1;
		y2 = y1;
		x1 = gra_x;
		y1 = gra_y;
		}

	code = code_peek();
	if	( code == kwCOLOR )	{
		code_skipnext();
		color = par_getint();	if ( prog_error )	return;
		}

	/* draw */
	gra_x = x2;
	gra_y = y2;

	if	( color != dev_fgcolor )	{
		int		prev_color = dev_fgcolor;

		dev_setcolor(color);
		dev_line(x1, y1, x2, y2);
		dev_setcolor(prev_color);
		}
	else
		dev_line(x1, y1, x2, y2);
}

//
//	RECT [STEP] x, y [{,|STEP} x2, y2] [COLOR color] [FILLED]
//
void	cmd_rect()
{
	int		x1, y1,	x2, y2, fill = 0;
	int		step1 = 0, step2 = 0;
	int		color = dev_fgcolor;
	byte	code;

	/* [STEP] x, y */
	code = code_peek();
	if	( code == kwSTEP )	{
		code_skipnext();
		step1 = 1;
		}

	x1 = par_getint();	if ( prog_error )	return;
	par_getcomma();		if ( prog_error )	return;
	y1 = par_getint();	if ( prog_error )	return;
	if	( step1 )
		( x1 += gra_x, y1 += gra_y );

	code = code_peek();
	if	( code == kwTYPE_SEP || code == kwSTEP )	{
		/* x, y [STEP] ? */
		if	( code == kwSTEP )	{
			code_skipnext();
			step2 = 1;
			}
		else	{
			par_getcomma();		
			if ( prog_error )	return;
			}

		/* [STEP] x, y [,|STEP] x2, y2 */
		x2 = par_getint();	if ( prog_error )	return;
		par_getcomma();		if ( prog_error )	return;
		y2 = par_getint();	if ( prog_error )	return;
		if	( step2 )
			( x2 += x1, y2 += y1 );
		}
	else	{
		x2 = x1;
		y2 = y1;
		x1 = gra_x;
		y1 = gra_y;
		}

	if	( code_peek() == kwCOLOR )	{
		code_skipnext();
		color = par_getint();	if ( prog_error )	return;
		}
	if	( code_peek() == kwFILLED )	{
		code_skipnext();
		fill = 1;
		}

	/* draw */
	gra_x = x2;
	gra_y = y2;

	if	( color != dev_fgcolor )	{
		int		prev_color = dev_fgcolor;

		dev_setcolor(color);
		dev_rect(x1, y1, x2, y2, fill);
		dev_setcolor(prev_color);
		}
	else
		dev_rect(x1, y1, x2, y2, fill);
}

//
//	DRAWPOLY v() [, xorg, yorg [, scale] [COLOR color] // [FILLED]
//
//	0,2,4... x 
//  1,3,5... y
//
void	cmd_drawpoly()
{
	var_t	*var_p, *elem_p;
	int		i, count;
	int		*pts, xorg = 0, yorg = 0;
	int		prev_color = dev_fgcolor;
	int		color = dev_fgcolor;
	int		filled = 0, scalef = 0;
	double	scale = 1.0;

	// array
	if	( !code_isnullarray() )	{
		err_typemismatch();
		return;
		}
	code_skipnext();
	var_p = tvar[code_getnext16()];
	count = var_p->size;

	// x,y origin
	if	( code_peek() == kwTYPE_SEP )	{
		par_getcomma();			if	( prog_error )	return;
		xorg = par_getint();	if	( prog_error )	return;
		par_getcomma();			if	( prog_error )	return;
		yorg = par_getint();	if	( prog_error )	return;

		// scale factor
		if	( code_peek() == kwTYPE_SEP )	{
			par_getcomma();			if	( prog_error )	return;
			scale = par_getnum();	if	( prog_error )	return;
			scalef ++;
			}
		}

	// color
	if	( code_peek() == kwCOLOR )	{
		code_skipnext();
		color = par_getint();	if ( prog_error )	return;
		}

	// filled
	if	( code_peek() == kwFILLED )	{
		code_skipnext();
		filled ++;
		}

	// get array's values
	pts = (int *) tmp_alloc(sizeof(int) * count);
	if	( scalef == 0 )	{
		for ( i = 0; i < count; i ++ )	{
			elem_p = v_getelemptr(var_p, i);
			if	( prog_error )	{
				tmp_free(pts);
				return;
				}

			switch ( elem_p->type )	{
			case	V_INT:
				pts[i] = elem_p->i;
				break;
			case	V_NUM:
				pts[i] = elem_p->n;
				break;
			case	V_STR:
				pts[i] = v_getval(elem_p);
				break;
			default:
				err_typemismatch();
				tmp_free(pts);
				return;
				}

			pts[i] += ( ((i % 2) == 0) ? xorg : yorg);
			}
		}
	else	{
		for ( i = 0; i < count; i ++ )	{
			elem_p = v_getelemptr(var_p, i);
			if	( prog_error )	{
				tmp_free(pts);
				return;
				}

			switch ( elem_p->type )	{
			case	V_INT:
				pts[i] = ((double) elem_p->i) * scale;
				break;
			case	V_NUM:
				pts[i] = elem_p->n * scale;
				break;
			case	V_STR:
				pts[i] = v_getval(elem_p) * scale;
				break;
			default:
				err_typemismatch();
				tmp_free(pts);
				return;
				}

			pts[i] += ( ((i % 2) == 0) ? xorg : yorg);
			}
		}

	// ready
	if	( color != dev_fgcolor )
		dev_setcolor(color);

	count = count >> 1;
	for ( i = 1; i < count; i ++ )	
		dev_line(pts[(i-1)*2], pts[(i-1)*2+1], pts[i*2], pts[i*2+1]);

	// cleanup
	tmp_free(pts);

	if ( color != prev_color )
		dev_setcolor(prev_color);
}

//
//	CIRCLE [STEP] x, y, r [, aspect] [COLOR color] [FILLED]
//
void	cmd_circle()
{
	int		color = dev_fgcolor, fill = 0, step1 = 0;
	int		xc, yc, r;
	double	aspect = 1.0;
	byte	code;

	/* [STEP] x, y */
	code = code_peek();
	if	( code == kwSTEP )	{
		code_skipnext();
		step1 = 1;
		}

	// xc
	xc = par_getint();	if ( prog_error )	return;
	par_getcomma();		if ( prog_error )	return;
	// yc
	yc = par_getint();	if ( prog_error )	return;
	par_getcomma();		if ( prog_error )	return;
	// r
	r = par_getint();	if ( prog_error )	return;
	if	( step1 )
		( xc += gra_x, yc += gra_y );

	//  aspect
	if	( code_peek() == kwTYPE_SEP )	{
		par_getcomma();				if ( prog_error )	return;
		aspect = par_getnum();		if ( prog_error )	return;
		}

	// COLOR
	if	( code_peek() == kwCOLOR )	{
		code_skipnext();
		color = par_getint();	if ( prog_error )	return;
		}

	// FILLED
	if	( code_peek() == kwFILLED )	{
		code_skipnext();
		fill = 1;
		}

	if	( color != dev_fgcolor )	{
		int		prev_color = dev_fgcolor;

		dev_setcolor(color);
		dev_ellipse(xc, yc, r, r, aspect, fill);
		dev_setcolor(prev_color);
		}
	else	
		dev_ellipse(xc, yc, r, r, aspect, fill);
}

//
//	ARC [STEP] x, y, r, start, end [, aspect] [COLOR color]
//
void	cmd_arc()
{
	int		color = dev_fgcolor, step1 = 0;
	int		xc, yc, r;
	double	as, ae, aspect = 1.0;
	byte	code;

	/* [STEP] x, y */
	code = code_peek();
	if	( code == kwSTEP )	{
		code_skipnext();
		step1 = 1;
		}

	// x
	xc = par_getint();	if ( prog_error )	return;

	// y
	par_getcomma();		if ( prog_error )	return;
	yc = par_getint();	if ( prog_error )	return;

	// r
	par_getcomma();		if ( prog_error )	return;
	r = par_getint();	if ( prog_error )	return;

	// a.st.
	par_getcomma();		if ( prog_error )	return;
	as = par_getnum();	if ( prog_error )	return;

	// a.end
	par_getcomma();		if ( prog_error )	return;
	ae = par_getnum();	if ( prog_error )	return;

	if	( step1 )
		( xc += gra_x, yc += gra_y );

	// aspect
	if	( code_peek() == kwTYPE_SEP )	{
		par_getcomma();			if ( prog_error )	return;
		aspect = par_getnum();	if ( prog_error )	return;
		}

	if	( code_peek() == kwCOLOR )	{
		code_skipnext();
		color = par_getint();	if ( prog_error )	return;
		}

	if	( color != dev_fgcolor )	{
		int		prev_color = dev_fgcolor;

		dev_setcolor(color);
		dev_arc(xc, yc, r, as, ae, aspect);
		dev_setcolor(prev_color);
		}
	else	
		dev_arc(xc, yc, r, as, ae, aspect);
}

//
char	*draw_getval(const char *src, int *c)
{
	char	*p = (char *) src;
	char	*dst, buf[64];

	dst = buf;
	p ++;
	*c = 0;
	if	( *p == '-' )	{
		*dst = '-';
		dst ++;
		p ++;
		}

	while ( is_digit(*p) )	
		*dst ++ = *p ++;
	*dst = '\0';

	*c = xstrtol(buf);
	return p;
}

//
//	DRAW "commands"
//
void	cmd_draw()
{
	register int draw=1, update=1;
	int		x, y, r;
	int		prev_color = dev_fgcolor;
	char	*p;
	var_t	var;

	par_getstr(&var);	if ( prog_error )	return;
	p = var.ptr;
	while ( *p )	{