OpenXM_contrib2/asir2000/plot/if.c - diff

Return to if.c CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / plot

Diff for /OpenXM_contrib2/asir2000/plot/if.c between version 1.3 and 1.8

version 1.3, 2000/08/22 05:04:31

version 1.8, 2001/12/25 02:39:07

Line 45

* DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,

* PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.

* $OpenXM: OpenXM_contrib2/asir2000/plot/if.c,v 1.2 2000/08/21 08:31:50 noro Exp $

* $OpenXM: OpenXM_contrib2/asir2000/plot/if.c,v 1.7 2001/10/09 01:36:27 noro Exp $

#include "ca.h"

#include "parse.h"

#include "ox.h"

#include "ifplot.h"

extern jmp_buf ox_env;

extern JMP_BUF ox_env;

int open_canvas(NODE arg)

{

int id;

struct canvas *can;

LIST wsize;

STRING wname;

wsize = (LIST)ARG0(arg);

wname = (STRING)ARG1(arg);

can = canvas[id = search_canvas()];

can->mode = MODE_INTERACTIVE;

if ( !wsize ) {

can->width = DEFAULTWIDTH; can->height = DEFAULTHEIGHT;

} else {

can->width = QTOS((Q)BDY(BDY(wsize)));

can->height = QTOS((Q)BDY(NEXT(BDY(wsize))));

}

if ( wname )

can->wname = BDY(wname);

else

can->wname = "";

create_canvas(can);

return id;

}

int plot(NODE arg)

{

int id;

Line 111 int plot(NODE arg)

Line 137 int plot(NODE arg)

return id;

}

int memory_plot(NODE arg,LIST *bytes)

{

NODE n;

struct canvas tmp_can;

struct canvas *can;

P formula;

LIST xrange,yrange,zrange,wsize;

int width,height;

double **tabe;

int i;

BYTEARRAY barray;

Q qw,qh;

formula = (P)ARG0(arg);

xrange = (LIST)ARG1(arg);

yrange = (LIST)ARG2(arg);

zrange = (LIST)ARG3(arg);

wsize = (LIST)ARG4(arg);

can = &tmp_can;

n = BDY(xrange); can->vx = VR((P)BDY(n)); n = NEXT(n);

can->qxmin = (Q)BDY(n); n = NEXT(n); can->qxmax = (Q)BDY(n);

can->xmin = ToReal(can->qxmin); can->xmax = ToReal(can->qxmax);

if ( yrange ) {

n = BDY(yrange); can->vy = VR((P)BDY(n)); n = NEXT(n);

can->qymin = (Q)BDY(n); n = NEXT(n); can->qymax = (Q)BDY(n);

can->ymin = ToReal(can->qymin); can->ymax = ToReal(can->qymax);

if ( zrange ) {

n = NEXT(BDY(zrange));

can->zmin = ToReal(BDY(n)); n = NEXT(n); can->zmax = ToReal(BDY(n));

if ( n = NEXT(n) )

can->nzstep = QTOS((Q)BDY(n));

else

can->nzstep = MAXGC;

can->mode = MODE_CONPLOT;

} else

can->mode = MODE_IFPLOT;

} else

can->mode = MODE_PLOT;

if ( !wsize ) {

can->width = DEFAULTWIDTH; can->height = DEFAULTHEIGHT;

} else {

can->width = QTOS((Q)BDY(BDY(wsize)));

can->height = QTOS((Q)BDY(NEXT(BDY(wsize))));

}

can->wname = "";

can->formula = formula;

if ( can->mode == MODE_PLOT )

plotcalc(can);

else {

width = can->width; height = can->height;

tabe = (double **)ALLOCA(width*sizeof(double *));

for ( i = 0; i < width; i++ )

tabe[i] = (double *)ALLOCA(height*sizeof(double));

calc(tabe,can,1);

memory_if_print(tabe,can,&barray);

STOQ(width,qw); STOQ(height,qh);

n = mknode(3,qw,qh,barray);

MKLIST(*bytes,n);

}

int plotover(NODE arg)

{

int index;

Line 124 int plotover(NODE arg)

Line 212 int plotover(NODE arg)

can = canvas[index];

if ( !can->window )

return -1;

get_vars_recursive(formula,&vl);

get_vars_recursive((Obj)formula,&vl);

for ( vl0 = vl; vl0; vl0 = NEXT(vl0) )

if ( vl0->v->attr == V_IND )

if ( vl0->v->attr == (pointer)V_IND )

if ( vl->v != can->vx && vl->v != can->vy )

return -1;

current_can = can;

Line 142 int plotover(NODE arg)

Line 230 int plotover(NODE arg)

int drawcircle(NODE arg)

{

#if !defined(VISUAL)

int id;

int index;

pointer ptr;

Line 167 int drawcircle(NODE arg)

Line 256 int drawcircle(NODE arg)

copy_to_canvas(can);

return index;

}

#endif

}

int draw_obj(NODE arg)

{

int index;

int x,y,u,v,len,r;

NODE obj,n;

RealVect *vect;

struct canvas *can;

int color;

index = QTOS((Q)ARG0(arg));

can = canvas[index];

if ( !can || !can->window ) {

set_lasterror("draw_obj : canvas does not exist");

return -1;

}

obj = BDY((LIST)ARG1(arg));

if ( argc(arg) == 3 )

color = QTOS((Q)ARG2(arg));

else

color = 0; /* black */

switch ( len = length(obj) ) {

case 2: /* point */

x = (int)ToReal((Q)ARG0(obj)); y = (int)ToReal((Q)ARG1(obj));

draw_point(display,can,x,y,color);

MKRVECT2(vect,x,y); MKNODE(n,vect,can->history); can->history = n;

break;

case 3: /* circle */

x = (int)ToReal((Q)ARG0(obj)); y = (int)ToReal((Q)ARG1(obj));

r = (int)ToReal((Q)ARG2(obj));

MKRVECT3(vect,x,y,r); MKNODE(n,vect,can->history); can->history = n;

break;

case 4: /* line */

x = (int)ToReal((Q)ARG0(obj)); y = (int)ToReal((Q)ARG1(obj));

u = (int)ToReal((Q)ARG2(obj)); v = (int)ToReal((Q)ARG3(obj));

draw_line(display,can,x,y,u,v,color);

MKRVECT4(vect,x,y,u,v); MKNODE(n,vect,can->history); can->history = n;

break;

default:

set_lasterror("draw_obj : invalid request");

return -1;

}

return 0;

}

int clear_canvas(NODE arg)

{

int index;

struct canvas *can;

index = QTOS((Q)ARG0(arg));

can = canvas[index];

if ( !can || !can->window )

return -1;

clear_pixmap(can);

copy_to_canvas(can);

/* clear the history */

can->history = 0;

}

#define RealtoDbl(r) ((r)?BDY(r):0.0)

int arrayplot(NODE arg)

Line 178 int arrayplot(NODE arg)

Line 328 int arrayplot(NODE arg)

LIST xrange,wsize;

char *wname;

NODE n;

Q ret;

double ymax,ymin,dy,xstep;

Real *tab;

struct canvas *can;

Line 230 int arrayplot(NODE arg)

Line 379 int arrayplot(NODE arg)

else if ( t < -MAXSHORT )

pa[ix].y = -MAXSHORT;

else

pa[ix].y = t;

pa[ix].y = (long)t;

}

plot_print(display,can);

copy_to_canvas(can);

return id;

}

ifplot_resize(can,spos,epos)

void ifplot_resize(struct canvas *can,POINT spos,POINT epos)

struct canvas *can;

POINT spos,epos;

{

struct canvas *ncan;

struct canvas fakecan;

Line 248 POINT spos,epos;

Line 395 POINT spos,epos;

Q s,t;

int new;

int w,h,m;

Q ret;

if ( XC(spos) < XC(epos) && YC(spos) < YC(epos) ) {

if ( can->precise && !can->wide ) {

Line 297 POINT spos,epos;

Line 443 POINT spos,epos;

if ( can->precise && !can->wide ) {

current_can = can;

alloc_pixmap(ncan);

#if defined(VISUAL)

ncan->real_can = can;

#endif

qifplotmain(ncan);

copy_subimage(ncan,can,spos);

copy_to_canvas(can);

Line 311 POINT spos,epos;

Line 460 POINT spos,epos;

}

plot_resize(can,spos,epos)

void plot_resize(struct canvas *can,POINT spos,POINT epos)

struct canvas *can;

POINT spos,epos;

{

struct canvas *ncan;

Q dx,dx2,xmin,xmax,xmid;

double dy,dy2,ymin,ymax,ymid;

double dy,ymin,ymax,ymid;

Q sx,ex,cw,ten,two;

double sy,ey;

Q s,t;

int new;

int w,h,m;

Line 371 POINT spos,epos;

Line 517 POINT spos,epos;

}

ifplotmain(can)

void ifplotmain(struct canvas *can)

struct canvas *can;

{

int width,height;

double **tabe,*tabeb;

double **tabe;

int i;

width = can->width; height = can->height;

Line 384 struct canvas *can;

Line 529 struct canvas *can;

tabe[i] = (double *)ALLOCA(height*sizeof(double));

define_cursor(can->window,runningcur);

set_busy(can); set_selection();

calc(tabe,can); if_print(display,tabe,can);

calc(tabe,can,0); if_print(display,tabe,can);

reset_selection(); reset_busy(can);

define_cursor(can->window,normalcur);

}

qifplotmain(can)

void qifplotmain(struct canvas *can)

struct canvas *can;

{

int width,height;

char **tabe,*tabeb;

Line 398 struct canvas *can;

Line 542 struct canvas *can;

width = can->width; height = can->height;

tabe = (char **)ALLOCA(width*sizeof(char *)+width*height*sizeof(char));

bzero(tabe,width*sizeof(char *)+width*height*sizeof(char));

bzero((void *)tabe,width*sizeof(char *)+width*height*sizeof(char));

for ( i = 0, tabeb = (char *)(tabe+width); i < width; i++ )

tabe[i] = tabeb + height*i;

define_cursor(can->window,runningcur);

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>