version 1.5, 2000/11/09 01:51:12 |
version 1.27, 2014/05/12 16:54:41 |
|
|
* DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE, |
* DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE, |
* PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE. |
* PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE. |
* |
* |
* $OpenXM: OpenXM_contrib2/asir2000/plot/if.c,v 1.4 2000/11/07 06:06:40 noro Exp $ |
* $OpenXM: OpenXM_contrib2/asir2000/plot/if.c,v 1.26 2014/03/25 19:22:15 ohara Exp $ |
*/ |
*/ |
#include "ca.h" |
#include "ca.h" |
#include "parse.h" |
#include "parse.h" |
#include "ox.h" |
#include "ox.h" |
#include "ifplot.h" |
#include "ifplot.h" |
|
|
extern jmp_buf ox_env; |
#if defined(INTERVAL) |
|
// Time message and func |
|
#include <sys/types.h> |
|
#include <sys/resource.h> |
|
#include <sys/time.h> |
|
|
int open_canvas(NODE arg) |
static struct oEGT ltime; |
|
static double r0; |
|
double get_rtime(); |
|
#if defined(ITV_TIME_CHECK) |
|
void tstart() |
{ |
{ |
|
get_eg(<ime); |
|
r0=get_rtime(); |
|
} |
|
|
|
void tstop(struct canvas *can) |
|
{ |
|
struct oEGT egt1; |
|
double e, g, r; |
|
char ts[100]; |
|
void popdown_warning(); |
|
Widget warnshell,warndialog; |
|
|
|
get_eg(&egt1); |
|
e=egt1.exectime - ltime.exectime; |
|
g=egt1.gctime - ltime.gctime; |
|
r=get_rtime() - r0; |
|
sprintf(ts,"(%8.6f + gc %8.6f) total %8.6f \n",e,g,r); |
|
create_popup(can->shell,"Message",&ts,&warnshell,&warndialog); |
|
XawDialogAddButton(warndialog,"OK",popdown_warning,warnshell); |
|
XtPopup(warnshell,XtGrabNone); |
|
SetWM_Proto(warnshell); |
|
} |
|
#else |
|
#define tstart() |
|
#define tstop(a) |
|
#endif |
|
#endif |
|
|
|
extern JMP_BUF ox_env; |
|
|
|
int open_canvas(NODE arg){ |
int id; |
int id; |
struct canvas *can; |
struct canvas *can; |
LIST wsize; |
LIST wsize; |
STRING wname; |
STRING wname; |
|
|
wsize = (LIST)ARG0(arg); |
wsize=(LIST)ARG0(arg); |
wname = (STRING)ARG1(arg); |
wname=(STRING)ARG1(arg); |
|
id=search_canvas(); |
can = canvas[id = search_canvas()]; |
can=canvas[id]; |
can->mode = MODE_INTERACTIVE; |
can->mode=modeNO(INTERACTIVE); |
if ( !wsize ) { |
if(!wsize){ |
can->width = DEFAULTWIDTH; can->height = DEFAULTHEIGHT; |
can->width=DEFAULTWIDTH; |
|
can->height=DEFAULTHEIGHT; |
} else { |
} else { |
can->width = QTOS((Q)BDY(BDY(wsize))); |
can->width=QTOS((Q)BDY(BDY(wsize))); |
can->height = QTOS((Q)BDY(NEXT(BDY(wsize)))); |
can->height=QTOS((Q)BDY(NEXT(BDY(wsize)))); |
} |
} |
if ( wname ) |
if(wname)can->wname=BDY(wname); |
can->wname = BDY(wname); |
else can->wname=""; |
else |
|
can->wname = ""; |
|
create_canvas(can); |
create_canvas(can); |
return id; |
return id; |
} |
} |
|
|
int plot(NODE arg) |
int plot(NODE arg,char *fn){ |
{ |
|
int id; |
int id; |
NODE n; |
NODE n; |
struct canvas *can; |
struct canvas *can; |
P formula; |
P formula; |
LIST xrange,yrange,zrange,wsize; |
LIST xrange,yrange,zrange,wsize; |
STRING wname; |
STRING wname; |
|
V v; |
|
|
formula = (P)ARG0(arg); |
formula=(P)ARG0(arg); |
xrange = (LIST)ARG1(arg); |
xrange=(LIST)ARG1(arg); |
yrange = (LIST)ARG2(arg); |
yrange=(LIST)ARG2(arg); |
zrange = (LIST)ARG3(arg); |
zrange=(LIST)ARG3(arg); |
wsize = (LIST)ARG4(arg); |
wsize=(LIST)ARG4(arg); |
wname = (STRING)ARG5(arg); |
wname=(STRING)ARG5(arg); |
|
can=canvas[id=search_canvas()]; |
can = canvas[id = search_canvas()]; |
if(xrange){ |
n = BDY(xrange); can->vx = VR((P)BDY(n)); n = NEXT(n); |
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->qxmin=(Q)BDY(n);n=NEXT(n);can->qxmax=(Q)BDY(n); |
can->xmin = ToReal(can->qxmin); can->xmax = ToReal(can->qxmax); |
can->xmin=ToReal(can->qxmin);can->xmax=ToReal(can->qxmax); |
if ( yrange ) { |
} |
n = BDY(yrange); can->vy = VR((P)BDY(n)); n = NEXT(n); |
if(yrange){ |
can->qymin = (Q)BDY(n); n = NEXT(n); can->qymax = (Q)BDY(n); |
n=BDY(yrange);can->vy=VR((P)BDY(n));n=NEXT(n); |
can->ymin = ToReal(can->qymin); can->ymax = ToReal(can->qymax); |
can->qymin=(Q)BDY(n);n=NEXT(n);can->qymax=(Q)BDY(n); |
if ( zrange ) { |
can->ymin=ToReal(can->qymin);can->ymax=ToReal(can->qymax); |
n = NEXT(BDY(zrange)); |
} |
can->zmin = ToReal(BDY(n)); n = NEXT(n); can->zmax = ToReal(BDY(n)); |
can->mode=modeNO(fn); |
if ( n = NEXT(n) ) |
if(zrange){ |
can->nzstep = QTOS((Q)BDY(n)); |
n=BDY(zrange); can->zmin=ToReal(BDY(n)); |
else |
n=NEXT(n);can->zmax=ToReal(BDY(n)); |
can->nzstep = MAXGC; |
n=NEXT(n); |
can->mode = MODE_CONPLOT; |
if(can->mode==modeNO(CONPLOT))can->nzstep=QTOS((Q)BDY(n)); |
} else |
else { |
can->mode = MODE_IFPLOT; |
can->vx=VR((P)BDY(BDY(zrange))); |
} else |
can->nzstep=QTOS((Q)BDY(n)); |
can->mode = MODE_PLOT; |
} |
if ( !wsize ) { |
} |
can->width = DEFAULTWIDTH; can->height = DEFAULTHEIGHT; |
if(!wsize){ |
|
can->width=DEFAULTWIDTH; |
|
can->height=DEFAULTHEIGHT; |
} else { |
} else { |
can->width = QTOS((Q)BDY(BDY(wsize))); |
can->width=QTOS((Q)BDY(BDY(wsize))); |
can->height = QTOS((Q)BDY(NEXT(BDY(wsize)))); |
can->height=QTOS((Q)BDY(NEXT(BDY(wsize)))); |
} |
} |
if ( wname ) |
if(wname) can->wname = BDY(wname); |
can->wname = BDY(wname); |
else can->wname=""; |
else |
can->formula=formula; |
can->wname = ""; |
if(can->mode==modeNO(PLOT)){ |
can->formula = formula; |
//plot |
create_canvas(can); |
|
if ( can->mode == MODE_PLOT ) { |
|
plotcalc(can); |
plotcalc(can); |
|
create_canvas(can); |
plot_print(display,can); |
plot_print(display,can); |
} else |
} else { |
ifplotmain(can); |
//ifplot,conplot |
|
create_canvas(can); |
|
ifplotmainOld(can); |
|
} |
copy_to_canvas(can); |
copy_to_canvas(can); |
return id; |
return id; |
} |
} |
|
|
int plotover(NODE arg) |
void ifplotmainOld(struct canvas *can){ |
{ |
int i,width,height; |
int index; |
double ** tabe; |
|
|
|
width=can->width;height=can->height; |
|
tabe=(double **)ALLOCA((width+1)*sizeof(double *)); |
|
for(i=0;i<width;i++)tabe[i]=(double *)ALLOCA((height+1)*sizeof(double)); |
|
define_cursor(can->window,runningcur); |
|
set_busy(can); set_selection(); |
|
calc(tabe,can,0); |
|
if_printOld(display,tabe,can); |
|
reset_selection(); reset_busy(can); |
|
define_cursor(can->window,normalcur); |
|
} |
|
|
|
int memory_plot(NODE arg,LIST *bytes){ |
|
NODE n; |
|
struct canvas tmp_can; |
|
struct canvas *can; |
P formula; |
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); |
|
|
|
bzero((char *)&tmp_can,sizeof(tmp_can)); |
|
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)); |
|
n=NEXT(n); |
|
if(n) can->nzstep=QTOS((Q)BDY(n)); |
|
else can->nzstep=MAXGC; |
|
can->mode=modeNO(CONPLOT); |
|
} else |
|
can->mode=modeNO(IFPLOT); |
|
} else |
|
can->mode=modeNO(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==modeNO(PLOT)){ |
|
plotcalc(can); |
|
memory_print(can,&barray); |
|
STOQ(can->width,qw); STOQ(can->height,qh); |
|
n=mknode(3,qw,qh,barray); |
|
MKLIST(*bytes,n); |
|
} 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); |
|
} |
|
return 0; |
|
} |
|
|
|
int plotover(NODE arg){ |
|
int id,orgcolor,color; |
|
P formula; |
struct canvas *can; |
struct canvas *can; |
struct canvas fakecan; |
|
VL vl,vl0; |
VL vl,vl0; |
|
|
index = QTOS((Q)ARG0(arg)); |
id=QTOS((Q)ARG0(arg)); |
formula = (P)ARG1(arg); |
formula=(P)ARG1(arg); |
can = canvas[index]; |
can=canvas[id]; |
if ( !can->window ) |
orgcolor=can->color; |
return -1; |
if(argc(arg)==3) can->color=QTOS((Q)ARG2(arg)); |
get_vars_recursive(formula,&vl); |
else can->color=0; |
for ( vl0 = vl; vl0; vl0 = NEXT(vl0) ) |
get_vars_recursive((Obj)formula,&vl); |
if ( vl0->v->attr == V_IND ) |
for(vl0=vl;vl0;vl0=NEXT(vl0)) |
if ( vl->v != can->vx && vl->v != can->vy ) |
if(vl0->v->attr==(pointer)V_IND) |
return -1; |
if(vl->v!=can->vx && vl->v!=can->vy)return -1; |
current_can = can; |
if(argc(arg)==3) can->color=QTOS((Q)ARG2(arg)); |
fakecan = *can; fakecan.formula = formula; |
else can->color=0; |
if ( can->mode == MODE_PLOT ) { |
#if !defined(VISUAL) |
plotcalc(&fakecan); |
set_drawcolor(can->color); |
plot_print(display,&fakecan); |
#endif |
} else |
current_can=can; |
ifplotmain(&fakecan); |
can->formula=formula; |
copy_to_canvas(&fakecan); |
if(can->mode==modeNO(PLOT)){ |
return index; |
plotcalc(can); |
|
plot_print(display,can); |
|
} else ifplotmainOld(can); |
|
copy_to_canvas(can); |
|
can->color=color; |
|
#if !defined(VISUAL) |
|
set_drawcolor(can->color); |
|
#endif |
|
return id; |
} |
} |
|
|
int drawcircle(NODE arg) |
int drawcircle(NODE arg){ |
{ |
|
#if !defined(VISUAL) |
#if !defined(VISUAL) |
int id; |
int id,index,wx,wy,wr,c; |
int index; |
|
pointer ptr; |
pointer ptr; |
Q ret; |
Q ret; |
LIST xyr; |
LIST xyr; |
Obj x,y,r; |
Obj x,y,r; |
int wx,wy,wr; |
|
struct canvas *can; |
struct canvas *can; |
struct canvas fakecan; |
|
|
|
index = QTOS((Q)ARG0(arg)); |
index=QTOS((Q)ARG0(arg)); |
xyr = (LIST)ARG1(arg); |
xyr=(LIST)ARG1(arg); |
x = (Obj)ARG0(BDY(xyr)); y = (Obj)ARG1(BDY(xyr)); r = (Obj)ARG2(BDY(xyr)); |
x=(Obj)ARG0(BDY(xyr)); y=(Obj)ARG1(BDY(xyr)); r=(Obj)ARG2(BDY(xyr)); |
can = canvas[index]; |
c=QTOS((Q)ARG2(arg)); |
if ( !can->window ) |
can=canvas[index]; |
return -1; |
if(!can->window)return -1; |
else { |
else { |
current_can = can; |
current_can=can; |
wx = (ToReal(x)-can->xmin)*can->width/(can->xmax-can->xmin); |
set_drawcolor(c); |
wy = (can->ymax-ToReal(y))*can->height/(can->ymax-can->ymin); |
wx=(ToReal(x)-can->xmin)*can->width/(can->xmax-can->xmin); |
wr = ToReal(r); |
wy=(can->ymax-ToReal(y))*can->height/(can->ymax-can->ymin); |
XFillArc(display,can->pix,colorGC,wx-wr/2,wy-wr/2,wr,wr,0,360*64); |
wr=ToReal(r); |
|
XFillArc(display,can->pix,cdrawGC,wx-wr/2,wy-wr/2,wr,wr,0,360*64); |
copy_to_canvas(can); |
copy_to_canvas(can); |
|
set_drawcolor(can->color); |
return index; |
return index; |
} |
} |
#endif |
#endif |
} |
} |
|
|
int draw_obj(NODE arg) |
int draw_obj(NODE arg){ |
{ |
int index,color,x,y,u,v,len,r; |
int index; |
|
int x,y,u,v,len,r; |
|
NODE obj,n; |
NODE obj,n; |
RealVect *vect; |
RealVect *vect; |
struct canvas *can; |
struct canvas *can; |
int color; |
|
|
|
index = QTOS((Q)ARG0(arg)); |
index=QTOS((Q)ARG0(arg)); |
can = canvas[index]; |
can=canvas[index]; |
if ( !can || !can->window ) { |
if(!can && closed_canvas[index]){ |
|
canvas[index]=closed_canvas[index]; |
|
closed_canvas[index]=0; |
|
can=canvas[index]; |
|
popup_canvas(index); |
|
current_can=can; |
|
} else if(!can||(can && !can->window)){ |
set_lasterror("draw_obj : canvas does not exist"); |
set_lasterror("draw_obj : canvas does not exist"); |
return -1; |
return -1; |
} |
} |
|
|
obj = BDY((LIST)ARG1(arg)); |
obj=BDY((LIST)ARG1(arg)); |
if ( argc(arg) == 3 ) |
if(argc(arg)== 3) color=QTOS((Q)ARG2(arg)); |
color = QTOS((Q)ARG2(arg)); |
else color=0; // black |
else |
switch(len=length(obj)){ |
color = 0; /* black */ |
case 2: // point |
switch ( len = length(obj) ) { |
x=(int)ToReal((Q)ARG0(obj)); y=(int)ToReal((Q)ARG1(obj)); |
case 2: /* point */ |
|
x = (int)ToReal((Q)ARG0(obj)); y = (int)ToReal((Q)ARG1(obj)); |
|
draw_point(display,can,x,y,color); |
draw_point(display,can,x,y,color); |
MKRVECT2(vect,x,y); MKNODE(n,vect,can->history); can->history = n; |
MKRVECT3(vect,x,y,color); MKNODE(n,vect,can->history); |
|
can->history=n; |
break; |
break; |
case 3: /* circle */ |
case 3: // circle |
x = (int)ToReal((Q)ARG0(obj)); y = (int)ToReal((Q)ARG1(obj)); |
x=(int)ToReal((Q)ARG0(obj)); y=(int)ToReal((Q)ARG1(obj)); |
r = (int)ToReal((Q)ARG2(obj)); |
r=(int)ToReal((Q)ARG2(obj)); |
MKRVECT3(vect,x,y,r); MKNODE(n,vect,can->history); can->history = n; |
MKRVECT4(vect,x,y,r,color); MKNODE(n,vect,can->history); |
|
can->history=n; |
break; |
break; |
case 4: /* line */ |
case 4: // line |
x = (int)ToReal((Q)ARG0(obj)); y = (int)ToReal((Q)ARG1(obj)); |
x=(int)ToReal((Q)ARG0(obj)); y=(int)ToReal((Q)ARG1(obj)); |
u = (int)ToReal((Q)ARG2(obj)); v = (int)ToReal((Q)ARG3(obj)); |
u=(int)ToReal((Q)ARG2(obj)); v=(int)ToReal((Q)ARG3(obj)); |
draw_line(display,can,x,y,u,v,color); |
draw_line(display,can,x,y,u,v,color); |
MKRVECT4(vect,x,y,u,v); MKNODE(n,vect,can->history); can->history = n; |
MKRVECT5(vect,x,y,u,v,color); MKNODE(n,vect,can->history); |
|
can->history=n; |
break; |
break; |
default: |
default: |
set_lasterror("draw_obj : invalid request"); |
set_lasterror("draw_obj : invalid request"); |
return -1; |
return -1; |
} |
} |
|
#if !defined(VISUAL) |
|
set_drawcolor(can->color); |
|
#endif |
return 0; |
return 0; |
} |
} |
|
|
int clear_canvas(NODE arg) |
int draw_string(NODE arg){ |
{ |
int index,x,y,color; |
int index; |
char *str; |
|
NODE pos; |
struct canvas *can; |
struct canvas *can; |
|
|
index = QTOS((Q)ARG0(arg)); |
index=QTOS((Q)ARG0(arg)); |
can = canvas[index]; |
can=canvas[index]; |
if ( !can || !can->window ) |
if(!can && closed_canvas[index]){ |
|
canvas[index]=closed_canvas[index]; |
|
closed_canvas[index]=0; |
|
can=canvas[index]; |
|
popup_canvas(index); |
|
current_can=can; |
|
} else if(!can||(can && !can->window)){ |
|
set_lasterror("draw_obj : canvas does not exist"); |
return -1; |
return -1; |
|
} |
|
|
|
pos=BDY((LIST)ARG1(arg)); |
|
str=BDY((STRING)ARG2(arg)); |
|
if(argc(arg)==4)color=QTOS((Q)ARG3(arg)); |
|
else color=0; // black |
|
x=(int)ToReal((Q)ARG0(pos)); |
|
y=(int)ToReal((Q)ARG1(pos)); |
|
draw_character_string(display,can,x,y,str,color); |
|
#if !defined(VISUAL) |
|
set_drawcolor(can->color); |
|
#endif |
|
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); |
clear_pixmap(can); |
copy_to_canvas(can); |
copy_to_canvas(can); |
/* clear the history */ |
// clear the history |
can->history = 0; |
can->history=0; |
|
return 0; |
} |
} |
|
|
#define RealtoDbl(r) ((r)?BDY(r):0.0) |
#define RealtoDbl(r) ((r)?BDY(r):0.0) |
|
|
int arrayplot(NODE arg) |
int arrayplot(NODE arg){ |
{ |
|
int id,ix,w,h; |
int id,ix,w,h; |
VECT array; |
VECT array; |
LIST xrange,wsize; |
LIST xrange,wsize; |
char *wname; |
char *wname; |
NODE n; |
NODE n; |
Q ret; |
|
double ymax,ymin,dy,xstep; |
double ymax,ymin,dy,xstep; |
Real *tab; |
Real *tab; |
struct canvas *can; |
struct canvas *can; |
POINT *pa; |
POINT *pa; |
|
|
array = (VECT)ARG0(arg); |
array=(VECT)ARG0(arg); |
xrange = (LIST)ARG1(arg); |
xrange=(LIST)ARG1(arg); |
can = canvas[id = search_canvas()]; |
can=canvas[id=search_canvas()]; |
n = BDY(xrange); can->vx = VR((P)BDY(n)); n = NEXT(n); |
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->qxmin=(Q)BDY(n); n=NEXT(n); can->qxmax=(Q)BDY(n); |
can->xmin = ToReal(can->qxmin); can->xmax = ToReal(can->qxmax); |
can->xmin=ToReal(can->qxmin); can->xmax=ToReal(can->qxmax); |
if ( !wsize ) { |
if(!wsize){ |
can->width = DEFAULTWIDTH; can->height = DEFAULTHEIGHT; |
can->width=DEFAULTWIDTH; |
|
can->height=DEFAULTHEIGHT; |
} else { |
} else { |
can->width = QTOS((Q)BDY(BDY(wsize))); |
can->width=QTOS((Q)BDY(BDY(wsize))); |
can->height = QTOS((Q)BDY(NEXT(BDY(wsize)))); |
can->height=QTOS((Q)BDY(NEXT(BDY(wsize)))); |
} |
} |
can->wname = wname; can->formula = 0; can->mode = MODE_PLOT; |
can->wname=wname; can->formula=0; can->mode=modeNO(PLOT); |
create_canvas(can); |
create_canvas(can); |
w = array->len; |
w=array->len; |
h = can->height; |
h=can->height; |
tab = (Real *)BDY(array); |
tab=(Real *)BDY(array); |
if ( can->ymax == can->ymin ) { |
if(can->ymax==can->ymin){ |
for ( ymax = ymin = RealtoDbl(tab[0]), ix = 1; ix < w; ix++ ) { |
for(ymax=ymin=RealtoDbl(tab[0]),ix=1; ix<w; ix++){ |
if ( RealtoDbl(tab[ix]) > ymax ) |
if(RealtoDbl(tab[ix])>ymax)ymax=RealtoDbl(tab[ix]); |
ymax = RealtoDbl(tab[ix]); |
if(RealtoDbl(tab[ix])<ymin)ymin=RealtoDbl(tab[ix]); |
if ( RealtoDbl(tab[ix]) < ymin ) |
|
ymin = RealtoDbl(tab[ix]); |
|
} |
} |
can->ymax = ymax; can->ymin = ymin; |
can->ymax=ymax; |
|
can->ymin=ymin; |
} else { |
} else { |
ymax = can->ymax; ymin = can->ymin; |
ymax=can->ymax; |
|
ymin=can->ymin; |
} |
} |
dy = ymax-ymin; |
dy=ymax-ymin; |
can->pa = (struct pa *)MALLOC(sizeof(struct pa)); |
can->pa=(struct pa *)MALLOC(sizeof(struct pa)); |
can->pa[0].length = w; |
can->pa[0].length=w; |
can->pa[0].pos = pa = (POINT *)MALLOC(w*sizeof(POINT)); |
can->pa[0].pos=pa=(POINT *)MALLOC(w*sizeof(POINT)); |
xstep = (double)can->width/(double)(w-1); |
xstep=(double)can->width/(double)(w-1); |
for ( ix = 0; ix < w; ix++ ) { |
for(ix=0;ix<w;ix++){ |
#ifndef MAXSHORT |
#ifndef MAXSHORT |
#define MAXSHORT ((short)0x7fff) |
#define MAXSHORT ((short)0x7fff) |
#endif |
#endif |
double t; |
double t; |
|
|
pa[ix].x = (int)(ix*xstep); |
pa[ix].x=(int)(ix*xstep); |
t = (h - 1)*(ymax - RealtoDbl(tab[ix]))/dy; |
t=(h - 1)*(ymax - RealtoDbl(tab[ix]))/dy; |
if ( t > MAXSHORT ) |
if(t>MAXSHORT)pa[ix].y=MAXSHORT; |
pa[ix].y = MAXSHORT; |
else if(t<-MAXSHORT)pa[ix].y=-MAXSHORT; |
else if ( t < -MAXSHORT ) |
else pa[ix].y=(long)t; |
pa[ix].y = -MAXSHORT; |
|
else |
|
pa[ix].y = t; |
|
} |
} |
plot_print(display,can); |
plot_print(display,can); |
copy_to_canvas(can); |
copy_to_canvas(can); |
return id; |
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 *ncan; |
struct canvas fakecan; |
struct canvas fakecan; |
Q dx,dy,dx2,dy2,xmin,xmax,ymin,ymax,xmid,ymid; |
Q dx,dy,dx2,dy2,xmin,xmax,ymin,ymax,xmid,ymid; |
Line 336 POINT spos,epos; |
|
Line 494 POINT spos,epos; |
|
Q s,t; |
Q s,t; |
int new; |
int new; |
int w,h,m; |
int w,h,m; |
Q ret; |
|
|
|
if ( XC(spos) < XC(epos) && YC(spos) < YC(epos) ) { |
if(XC(spos)<XC(epos) && YC(spos)<YC(epos)){ |
if ( can->precise && !can->wide ) { |
if(can->precise && !can->wide){ |
fakecan = *can; ncan = &fakecan; |
fakecan=*can; |
|
ncan=&fakecan; |
} else { |
} else { |
new = search_canvas(); ncan = canvas[new]; |
new=search_canvas(); |
|
ncan=canvas[new]; |
} |
} |
ncan->mode = can->mode; |
ncan->mode=can->mode; |
ncan->zmin = can->zmin; ncan->zmax = can->zmax; |
ncan->zmin=can->zmin; ncan->zmax=can->zmax; |
ncan->nzstep = can->nzstep; |
ncan->nzstep=can->nzstep; |
ncan->wname = can->wname; |
ncan->wname=can->wname; |
ncan->vx = can->vx; ncan->vy = can->vy; |
ncan->vx=can->vx; ncan->vy=can->vy; |
ncan->formula = can->formula; |
ncan->formula=can->formula; |
w = XC(epos)-XC(spos); |
w=XC(epos)-XC(spos); |
h = YC(epos)-YC(spos); |
h=YC(epos)-YC(spos); |
m = MAX(can->width,can->height); |
m=MAX(can->width,can->height); |
if ( can->precise ) { |
if(can->precise){ |
ncan->width = w; ncan->height = h; |
ncan->width=w; |
} else if ( w > h ) { |
ncan->height=h; |
ncan->width = m; ncan->height = m * h/w; |
} else if(w>h){ |
|
ncan->width=m; |
|
ncan->height=m*h/w; |
} else { |
} else { |
ncan->width = m * w/h; ncan->height = m; |
ncan->width=m*w/h; |
|
ncan->height=m; |
} |
} |
if ( can->wide ) { |
if(can->wide){ |
STOQ(10,ten); STOQ(2,two); |
STOQ(10,ten); |
subq(can->qxmax,can->qxmin,&t); mulq(t,ten,&dx); |
STOQ(2,two); |
subq(can->qymax,can->qymin,&t); mulq(t,ten,&dy); |
subq(can->qxmax,can->qxmin,&t); |
addq(can->qxmax,can->qxmin,&t); divq(t,two,&xmid); |
mulq(t,ten,&dx); |
addq(can->qymax,can->qymin,&t); divq(t,two,&ymid); |
subq(can->qymax,can->qymin,&t); |
divq(dx,two,&dx2); divq(dy,two,&dy2); |
mulq(t,ten,&dy); |
subq(xmid,dx2,&xmin); addq(xmid,dx2,&xmax); |
addq(can->qxmax,can->qxmin,&t); |
subq(ymid,dy2,&ymin); addq(ymid,dy2,&ymax); |
divq(t,two,&xmid); |
|
addq(can->qymax,can->qymin,&t); |
|
divq(t,two,&ymid); |
|
divq(dx,two,&dx2); |
|
divq(dy,two,&dy2); |
|
subq(xmid,dx2,&xmin); |
|
addq(xmid,dx2,&xmax); |
|
subq(ymid,dy2,&ymin); |
|
addq(ymid,dy2,&ymax); |
} else { |
} else { |
subq(can->qxmax,can->qxmin,&dx); subq(can->qymax,can->qymin,&dy); |
subq(can->qxmax,can->qxmin,&dx); |
xmin = can->qxmin; xmax = can->qxmax; |
subq(can->qymax,can->qymin,&dy); |
ymin = can->qymin; ymax = can->qymax; |
xmin=can->qxmin; |
|
xmax=can->qxmax; |
|
ymin=can->qymin; |
|
ymax=can->qymax; |
} |
} |
STOQ(XC(spos),sx); STOQ(YC(spos),sy); STOQ(XC(epos),ex); STOQ(YC(epos),ey); |
STOQ(XC(spos),sx); STOQ(YC(spos),sy); STOQ(XC(epos),ex); STOQ(YC(epos),ey); |
STOQ(can->width,cw); STOQ(can->height,ch); |
STOQ(can->width,cw); STOQ(can->height,ch); |
Line 380 POINT spos,epos; |
|
Line 553 POINT spos,epos; |
|
mulq(ex,dx,&t); divq(t,cw,&s); addq(xmin,s,&ncan->qxmax); |
mulq(ex,dx,&t); divq(t,cw,&s); addq(xmin,s,&ncan->qxmax); |
mulq(ey,dy,&t); divq(t,ch,&s); subq(ymax,s,&ncan->qymin); |
mulq(ey,dy,&t); divq(t,ch,&s); subq(ymax,s,&ncan->qymin); |
mulq(sy,dy,&t); divq(t,ch,&s); subq(ymax,s,&ncan->qymax); |
mulq(sy,dy,&t); divq(t,ch,&s); subq(ymax,s,&ncan->qymax); |
ncan->xmin = ToReal(ncan->qxmin); ncan->xmax = ToReal(ncan->qxmax); |
ncan->xmin=ToReal(ncan->qxmin); ncan->xmax=ToReal(ncan->qxmax); |
ncan->ymin = ToReal(ncan->qymin); ncan->ymax = ToReal(ncan->qymax); |
ncan->ymin=ToReal(ncan->qymin); ncan->ymax=ToReal(ncan->qymax); |
if ( can->precise && !can->wide ) { |
if(can->precise && !can->wide){ |
current_can = can; |
current_can=can; |
alloc_pixmap(ncan); |
alloc_pixmap(ncan); |
#if defined(VISUAL) |
#if defined(VISUAL) |
ncan->real_can = can; |
ncan->real_can=can; |
#endif |
#endif |
qifplotmain(ncan); |
qifplotmain(ncan); |
copy_subimage(ncan,can,spos); |
copy_subimage(ncan,can,spos); |
copy_to_canvas(can); |
copy_to_canvas(can); |
} else { |
} else { |
create_canvas(ncan); |
create_canvas(ncan); |
if ( can->precise ) |
if( can->precise ) qifplotmain(ncan); |
qifplotmain(ncan); |
else ifplotmain(ncan); |
else |
|
ifplotmain(ncan); |
|
copy_to_canvas(ncan); |
copy_to_canvas(ncan); |
} |
} |
} |
} |
} |
} |
|
|
plot_resize(can,spos,epos) |
void plot_resize(struct canvas *can,POINT spos,POINT epos){ |
struct canvas *can; |
|
POINT spos,epos; |
|
{ |
|
struct canvas *ncan; |
struct canvas *ncan; |
Q dx,dx2,xmin,xmax,xmid; |
Q dx,dx2,xmin,xmax,xmid; |
double dy,dy2,ymin,ymax,ymid; |
double dy,ymin,ymax,ymid; |
Q sx,ex,cw,ten,two; |
Q sx,ex,cw,ten,two; |
double sy,ey; |
|
Q s,t; |
Q s,t; |
int new; |
int new; |
int w,h,m; |
int w,h,m; |
|
|
if ( XC(spos) < XC(epos) && YC(spos) < YC(epos) ) { |
if( XC(spos)<XC(epos) && YC(spos)<YC(epos) ){ |
new = search_canvas(); ncan = canvas[new]; |
new=search_canvas(); ncan=canvas[new]; |
ncan->mode = can->mode; |
ncan->mode=can->mode; |
ncan->zmin = can->zmin; ncan->zmax = can->zmax; |
ncan->zmin=can->zmin; ncan->zmax=can->zmax; |
ncan->nzstep = can->nzstep; |
ncan->nzstep=can->nzstep; |
ncan->wname = can->wname; |
ncan->wname=can->wname; |
ncan->vx = can->vx; ncan->vy = can->vy; |
ncan->vx=can->vx; ncan->vy=can->vy; |
ncan->formula = can->formula; |
ncan->formula=can->formula; |
w = XC(epos)-XC(spos); |
w=XC(epos)-XC(spos); |
h = YC(epos)-YC(spos); |
h=YC(epos)-YC(spos); |
m = MAX(can->width,can->height); |
m=MAX(can->width,can->height); |
if ( w > h ) { |
if( w>h ){ |
ncan->width = m; ncan->height = m * h/w; |
ncan->width=m; ncan->height=m * h/w; |
} else { |
} else { |
ncan->width = m * w/h; ncan->height = m; |
ncan->width=m * w/h; ncan->height=m; |
} |
} |
if ( can->wide ) { |
if( can->wide ){ |
STOQ(10,ten); STOQ(2,two); |
STOQ(10,ten); STOQ(2,two); |
subq(can->qxmax,can->qxmin,&t); mulq(t,ten,&dx); |
subq(can->qxmax,can->qxmin,&t); mulq(t,ten,&dx); |
addq(can->qxmax,can->qxmin,&t); divq(t,two,&xmid); |
addq(can->qxmax,can->qxmin,&t); divq(t,two,&xmid); |
divq(dx,two,&dx2); subq(xmid,dx2,&xmin); addq(xmid,dx2,&xmax); |
divq(dx,two,&dx2); subq(xmid,dx2,&xmin); addq(xmid,dx2,&xmax); |
|
|
dy = (can->ymax-can->ymin)*10; |
dy=(can->ymax-can->ymin)*10; |
ymid = (can->ymax+can->ymin)/2; |
ymid=(can->ymax+can->ymin)/2; |
ymin = ymid-dy/2; ymax = ymid+dy/2; |
ymin=ymid-dy/2; ymax=ymid+dy/2; |
} else { |
} else { |
subq(can->qxmax,can->qxmin,&dx); |
subq(can->qxmax,can->qxmin,&dx); |
xmin = can->qxmin; xmax = can->qxmax; |
xmin=can->qxmin; xmax=can->qxmax; |
|
|
dy = can->ymax-can->ymin; |
dy=can->ymax-can->ymin; |
ymin = can->ymin; ymax = can->ymax; |
ymin=can->ymin; ymax=can->ymax; |
} |
} |
STOQ(XC(spos),sx); STOQ(XC(epos),ex); STOQ(can->width,cw); |
STOQ(XC(spos),sx); STOQ(XC(epos),ex); STOQ(can->width,cw); |
mulq(sx,dx,&t); divq(t,cw,&s); addq(xmin,s,&ncan->qxmin); |
mulq(sx,dx,&t); divq(t,cw,&s); addq(xmin,s,&ncan->qxmin); |
mulq(ex,dx,&t); divq(t,cw,&s); addq(xmin,s,&ncan->qxmax); |
mulq(ex,dx,&t); divq(t,cw,&s); addq(xmin,s,&ncan->qxmax); |
ncan->xmin = ToReal(ncan->qxmin); ncan->xmax = ToReal(ncan->qxmax); |
ncan->xmin=ToReal(ncan->qxmin); ncan->xmax=ToReal(ncan->qxmax); |
|
|
ncan->ymin = ymax-YC(epos)*dy/can->height; |
ncan->ymin=ymax-YC(epos)*dy/can->height; |
ncan->ymax = ymax-YC(spos)*dy/can->height; |
ncan->ymax=ymax-YC(spos)*dy/can->height; |
|
|
create_canvas(ncan); |
create_canvas(ncan); |
plotcalc(ncan); |
plotcalc(ncan); |
Line 462 POINT spos,epos; |
|
Line 629 POINT spos,epos; |
|
} |
} |
} |
} |
|
|
ifplotmain(can) |
void qifplotmain(struct canvas *can) |
struct canvas *can; |
|
{ |
{ |
int width,height; |
int width,height; |
double **tabe,*tabeb; |
char **tabe,*tabeb; |
int i; |
int i; |
|
|
width = can->width; height = can->height; |
width=can->width; height=can->height; |
tabe = (double **)ALLOCA(width*sizeof(double *)); |
tabe=(char **)ALLOCA(width*sizeof(char *)+width*height*sizeof(char)); |
for ( i = 0; i < width; i++ ) |
bzero((void *)tabe,width*sizeof(char *)+width*height*sizeof(char)); |
tabe[i] = (double *)ALLOCA(height*sizeof(double)); |
for( i=0, tabeb=(char *)(tabe+width); i<width; i++ ) |
|
tabe[i]=tabeb + height*i; |
define_cursor(can->window,runningcur); |
define_cursor(can->window,runningcur); |
set_busy(can); set_selection(); |
set_busy(can); set_selection(); |
calc(tabe,can); if_print(display,tabe,can); |
qcalc(tabe,can); qif_print(display,tabe,can); |
reset_selection(); reset_busy(can); |
reset_selection(); reset_busy(can); |
define_cursor(can->window,normalcur); |
define_cursor(can->window,normalcur); |
} |
} |
|
|
qifplotmain(can) |
//*******************ifplotNG |
struct canvas *can; |
int ifplotNG(NODE arg,int func){ |
{ |
int id,orgcolor,color,op_code; |
int width,height; |
NODE n; |
char **tabe,*tabeb; |
struct canvas *can; |
int i; |
P formula; |
|
LIST xrange,yrange,zrange,wsize; |
|
STRING wname; |
|
|
width = can->width; height = can->height; |
formula=(P)ARG0(arg); |
tabe = (char **)ALLOCA(width*sizeof(char *)+width*height*sizeof(char)); |
color=QTOS((Q)ARG1(arg)); |
bzero(tabe,width*sizeof(char *)+width*height*sizeof(char)); |
xrange=(LIST)ARG2(arg); |
for ( i = 0, tabeb = (char *)(tabe+width); i < width; i++ ) |
yrange=(LIST)ARG3(arg); |
tabe[i] = tabeb + height*i; |
zrange=(LIST)ARG4(arg); |
|
wsize=(LIST)ARG5(arg); |
|
wname=(STRING)ARG6(arg); |
|
|
|
can=canvas[id=search_canvas()]; |
|
orgcolor=can->color; |
|
can->color=color; |
|
can->division=0; |
|
// set canvas data |
|
if(xrange){ |
|
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=BDY(zrange); can->zmin=ToReal(BDY(n)); |
|
n=NEXT(n); can->zmax=ToReal(BDY(n)); |
|
n=NEXT(n); can->nzstep=QTOS((Q)BDY(n)); |
|
} |
|
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=""; |
|
can->formula=formula; |
|
set_drawcolor(color); |
|
can->mode=func; |
|
create_canvas(can); |
|
ifplotmain(can); |
|
set_drawcolor(orgcolor); |
|
copy_to_canvas(can); |
|
can->color=orgcolor; |
|
return id; |
|
} |
|
|
|
int ifplotOP(NODE arg,int func){ |
|
//ineqnor[D,Q,B],ineqnand[D,Q,B],ineqnxor[D,Q,b],plotover[D,Q,B] |
|
int index,orgcolor,color,op_code; |
|
P formula; |
|
struct canvas *can; |
|
VL vl,vl0; |
|
NODE n; |
|
|
|
index=QTOS((Q)ARG0(arg)); |
|
formula=(P)ARG1(arg); |
|
color=QTOS((Q)ARG2(arg)); |
|
// set canvas data |
|
can=canvas[index]; |
|
orgcolor=can->color; |
|
can->color=color; |
|
can->formula=formula; |
|
current_can=can; |
|
get_vars_recursive((Obj)formula,&vl); |
|
for(vl0=vl;vl0;vl0=NEXT(vl0)) |
|
if(vl0->v->attr==(pointer)V_IND) |
|
if(vl->v!=can->vx && vl->v!=can->vy)return -1; |
|
#if !defined(VISUAL) |
|
set_drawcolor(can->color); |
|
#endif |
|
can->mode=func; |
|
set_drawcolor(color); |
|
ifplotmain(can); |
|
set_drawcolor(orgcolor); |
|
copy_to_canvas(can); |
|
can->color=orgcolor; |
|
#if !defined(VISUAL) |
|
set_drawcolor(can->color); |
|
#endif |
|
return index; |
|
} |
|
|
|
void ifplotmain(struct canvas *can){ |
|
int width,height,i,j,ix,iy,**mask; |
|
double **tabe; |
|
|
|
width=can->width; height=can->height; |
|
tabe=(double **)ALLOCA((width+1)*sizeof(double *)); |
|
for(i=0;i<width;i++)tabe[i]=(double *)ALLOCA((height+1)*sizeof(double)); |
define_cursor(can->window,runningcur); |
define_cursor(can->window,runningcur); |
set_busy(can); set_selection(); |
set_busy(can); set_selection(); |
qcalc(tabe,can); qif_print(display,tabe,can); |
set_drawcolor(can->color); |
|
switch(can->mode){ |
|
case 6://IFPLOTD |
|
calc(tabe,can,0); |
|
if_print(display,tabe,can,1); |
|
break; |
|
case 7://IFPLOTQ |
|
calcq(tabe,can,0); |
|
if_print(display,tabe,can,1); |
|
break; |
|
case 8://IFPLOTB |
|
calcb(tabe,can,0); |
|
if_print(display,tabe,can,0); |
|
break; |
|
#if defined(INTERVAL) |
|
case 9://INEQND |
|
calc(tabe,can,0); |
|
area_print(display,tabe,can,0); |
|
break; |
|
case 10://INEQNQ |
|
calcq(tabe,can,0); |
|
area_print(display,tabe,can,0); |
|
break; |
|
case 11://INEQNB |
|
calcb(tabe,can,0); |
|
area_print(display,tabe,can,0); |
|
break; |
|
case 12://INEQNFAND |
|
calc(tabe,can,0); |
|
area_print(display,tabe,can,2); |
|
break; |
|
case 13://INEQNQAND |
|
calcq(tabe,can,0); |
|
area_print(display,tabe,can,2); |
|
break; |
|
case 14://INEQNBAND |
|
calcb(tabe,can,0); |
|
area_print(display,tabe,can,2); |
|
break; |
|
case 15://INEQNDOR |
|
calc(tabe,can,0); |
|
area_print(display,tabe,can,3); |
|
break; |
|
case 16://INEQNQOR |
|
calcq(tabe,can,0); |
|
area_print(display,tabe,can,3); |
|
break; |
|
case 17://INEQNBOR |
|
calcb(tabe,can,0); |
|
area_print(display,tabe,can,3); |
|
break; |
|
case 18://INEQNDXOR |
|
calc(tabe,can,0); |
|
area_print(display,tabe,can,4); |
|
break; |
|
case 19://INEQNQXOR |
|
calcq(tabe,can,0); |
|
area_print(display,tabe,can,4); |
|
break; |
|
case 20://INEQNBXOR |
|
calcb(tabe,can,0); |
|
area_print(display,tabe,can,4); |
|
break; |
|
case 21://CONPLOTD |
|
calc(tabe,can,0); |
|
con_print(display,tabe,can); |
|
break; |
|
case 22://CONPLOTQ |
|
calcq(tabe,can,0); |
|
con_print(display,tabe,can); |
|
break; |
|
case 23://CONPLOTB |
|
calcb(tabe,can,0); |
|
con_print(display,tabe,can); |
|
break; |
|
case 24://ITVIFPLOT: |
|
itvcalc(tabe,can,1); |
|
if_print(display,tabe,can,1); |
|
break; |
|
case 25://PLOTOVERD |
|
calc(tabe,can,0); |
|
over_print(display,tabe,can,0); |
|
break; |
|
case 26://PLOTOVERQ: |
|
calcq(tabe,can,0); |
|
over_print(display,tabe,can,0); |
|
break; |
|
case 27://PLOTOVERB: |
|
calcb(tabe,can,0); |
|
over_print(display,tabe,can,0); |
|
break; |
|
#endif |
|
} |
|
set_drawcolor(can->color); |
reset_selection(); reset_busy(can); |
reset_selection(); reset_busy(can); |
define_cursor(can->window,normalcur); |
define_cursor(can->window,normalcur); |
} |
} |
|
|
|
#if defined(INTERVAL) |
|
int objcp(NODE arg){ |
|
int idsrc, idtrg, op_code; |
|
struct canvas *cansrc, *cantrg; |
|
|
|
idsrc=QTOS((Q)ARG0(arg)); |
|
idtrg=QTOS((Q)ARG1(arg)); |
|
op_code=QTOS((Q)ARG2(arg)); |
|
cansrc=canvas[idsrc]; |
|
cantrg=canvas[idtrg]; |
|
obj_op(cansrc, cantrg, op_code); |
|
return idsrc; |
|
} |
|
|
|
void obj_op(struct canvas *cansrc, struct canvas *cantrg, int op){ |
|
XImage *imgsrc, *imgtrg; |
|
int width, height, i, j; |
|
unsigned long src, trg, black, white; |
|
|
|
width=cansrc->width; height=cansrc->height; |
|
imgsrc=XGetImage(display, cansrc->pix, 0, 0, width, height, -1, ZPixmap); |
|
imgtrg=XGetImage(display, cantrg->pix, 0, 0, width, height, -1, ZPixmap); |
|
black=GetColor(display, "black"); |
|
white=GetColor(display, "white"); |
|
flush(); |
|
define_cursor(cantrg->window,runningcur); |
|
set_busy(cantrg); set_selection(); |
|
cantrg->precise=cansrc->precise; |
|
cantrg->noaxis=cansrc->noaxis; |
|
cantrg->noaxisb=cansrc->noaxisb; |
|
cantrg->vx=cansrc->vx; |
|
cantrg->vy=cansrc->vy; |
|
cantrg->formula=cansrc->formula; |
|
cantrg->width=cansrc->width; |
|
cantrg->height=cansrc->height; |
|
cantrg->xmin=cansrc->xmin; |
|
cantrg->xmax=cansrc->xmax; |
|
cantrg->ymin=cansrc->ymin; |
|
cantrg->ymax=cansrc->ymax; |
|
cantrg->zmin=cansrc->zmin; |
|
cantrg->zmax=cansrc->zmax; |
|
cantrg->nzstep=cansrc->nzstep; |
|
cantrg->qxmin=cansrc->qxmin; |
|
cantrg->qxmax=cansrc->qxmax; |
|
cantrg->qymin=cansrc->qymin; |
|
cantrg->qymax=cansrc->qymax; |
|
cantrg->pa=cansrc->pa; |
|
switch(op){ |
|
case 1:/* and case */ |
|
for(i=0;i<width;i++)for(j=0;j<height;j++){ |
|
src=XGetPixel(imgsrc,i,j); |
|
trg=XGetPixel(imgtrg,i,j); |
|
if( (src == black) || (trg == black) ) |
|
XPutPixel(imgtrg,i,j,black); |
|
else if( (src == white) || (trg == white) ) |
|
XPutPixel(imgtrg,i,j,white); |
|
else XPutPixel(imgtrg,i,j,(src & trg)); |
|
} |
|
break; |
|
case 3:/* copy case */ |
|
imgtrg->data=imgsrc->data; |
|
break; |
|
case 6:/* xor case */ |
|
for(i=0;i<width;i++)for(j=0;j<height;j++){ |
|
src=XGetPixel(imgsrc,i,j); |
|
trg=XGetPixel(imgtrg,i,j); |
|
if( (src == black) || (trg == black) ) |
|
XPutPixel(imgtrg,i,j,black); |
|
else if( (src == white) && (trg == white) ) |
|
XPutPixel(imgtrg,i,j,trg|src); |
|
else if( (src != white) && (trg != white) ) |
|
XPutPixel(imgtrg,i,j,white); |
|
else if( src == white ) |
|
XPutPixel(imgtrg,i,j,src); |
|
} |
|
break; |
|
case 7:/* or case */ |
|
for(i=0;i<width;i++)for(j=0;j<height;j++){ |
|
src=XGetPixel(imgsrc,i,j); |
|
trg=XGetPixel(imgtrg,i,j); |
|
if( (src == black) || (trg == black) ) |
|
XPutPixel(imgtrg,i,j,black); |
|
else if(src == white) |
|
XPutPixel(imgtrg,i,j,trg); |
|
else if(trg == white) |
|
XPutPixel(imgtrg,i,j,src); |
|
} |
|
break; |
|
default: |
|
break; |
|
} |
|
XPutImage(display, cantrg->pix, drawGC, imgtrg, 0, 0, 0, 0, width, height); |
|
reset_selection(); reset_busy(cantrg); |
|
define_cursor(cantrg->window,normalcur); |
|
copy_to_canvas(cantrg); |
|
count_and_flush(); |
|
flush(); |
|
} |
|
int polarplotNG(NODE arg){ |
|
int i,id,color,orgcolor,width,height; |
|
NODE n; |
|
struct canvas *can; |
|
P formula; |
|
LIST range,geom; |
|
STRING wname; |
|
V v; |
|
|
|
formula=(P)ARG0(arg); |
|
color=QTOS((Q)ARG1(arg)); |
|
range=(LIST)ARG2(arg); |
|
geom=(LIST)ARG3(arg); |
|
wname=(STRING)ARG4(arg); |
|
|
|
id=search_canvas(); |
|
can=canvas[id]; |
|
can->mode=modeNO(POLARPLOT); |
|
if(range){ |
|
n=NEXT(BDY(range)); |
|
can->zmin=ToReal(BDY(n)); |
|
n=NEXT(n);can->zmax=ToReal(BDY(n)); |
|
n=NEXT(n); |
|
can->vx=VR((P)BDY(BDY(range))); |
|
can->nzstep=n?QTOS((Q)BDY(n)):DEFAULTPOLARSTEP; |
|
} |
|
if(geom){ |
|
can->width=width=QTOS((Q)BDY(BDY(geom))); |
|
can->height=height=QTOS((Q)BDY(NEXT(BDY(geom)))); |
|
} |
|
if(wname)can->wname=BDY(wname); |
|
else can->wname=""; |
|
can->formula=formula; |
|
orgcolor=can->color; |
|
can->color=color; |
|
polarcalc(can); |
|
create_canvas(can); |
|
set_drawcolor(color); |
|
polar_print(display,can); |
|
can->color=orgcolor; |
|
set_drawcolor(orgcolor); |
|
reset_selection(); reset_busy(can); |
|
define_cursor(can->window,normalcur); |
|
return id; |
|
} |
|
#endif |